MotionSensitiveTemporalSmoothing.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   : ICLFilter/src/ICLFilter/MotionSensitiveTemporalSmoothi **
**          ng.h                                                   **
** Module : ICLFilter                                              **
** Authors: Andre Ueckermann                                       **
**                                                                 **
**                                                                 **
** 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 <ICLFilter/UnaryOp.h>
#include <ICLCore/Img.h>
#include <ICLUtils/Uncopyable.h>

#ifdef HAVE_OPENCL    
#include <CL/cl.hpp>
#endif

namespace icl{
  namespace filter{
  
    class TemporalSmoothingCL{
      public:
      

      TemporalSmoothingCL(utils::Size size, core::depth depth, int iMaxFilterSize, int iNullValue);
  
      ~TemporalSmoothingCL();
      

      core::Img32f temporalSmoothingF(core::Img32f &inputImage);
      

      core::Img8u temporalSmoothingC(core::Img8u &inputImage);
      

            void setUseCL(bool use);
            

            void setFilterSize(int iFilterSize);
            

            void setDifference(int iDifference);
            

            core::Img32f getMotionImage();
            

            bool isCLReady();
            

            bool isCLActive();
                  
     private:
     
      int w,h;
      core::depth d;
      bool clReady;
      bool useCL;
      
      int imgCount;
      
      int filterSize;
      int currentFilterSize;
      int maxFilterSize;
      
      int currentDifference;
      int nullValue;
        
      std::vector<core::Img32f> inputImagesF;
      core::Img32f outputImageF;         
      std::vector<core::Img8u> inputImagesC;
      core::Img8u outputImageC; 
      core::Img32f motionImage;     
        
    #ifdef HAVE_OPENCL
      //OpenCL    
      float* inputImage1ArrayF;
      float* inputImagesArrayF;
      float* outputImageArrayF;
      
      cl_uchar* inputImage1ArrayC;
      cl_uchar* inputImagesArrayC;
      cl_uchar* outputImageArrayC;
      
      float* motionImageArray;
      
      cl::Context context;
      std::vector<cl::Device> devices;
      cl::Program program;
      cl::CommandQueue queue;
      
      cl::Kernel kernelTemporalSmoothingFloat;
      cl::Kernel kernelTemporalSmoothingChar;
      
      cl::Buffer inputImageBufferF;      
      cl::Buffer outputImageBufferF;
      cl::Buffer inputImageBufferC;
      cl::Buffer outputImageBufferC;
      cl::Buffer motionImageBuffer;
      
    #endif
  
    };
  
    class MotionSensitiveTemporalSmoothing : public UnaryOp, public utils::Uncopyable{
      public:
      

      MotionSensitiveTemporalSmoothing(int iNullValue, int iMaxFilterSize);
  
      ~MotionSensitiveTemporalSmoothing();
      

      virtual void apply(const core::ImgBase *src, core::ImgBase **dst);
          
      using UnaryOp::apply;
  

            void setUseCL(bool use);
            

            void setFilterSize(int filterSize);
            

            void setDifference(int difference);
            

            core::Img32f getMotionImage();
             

            bool isCLActive();
                  
     private:
     
      void init(int iChannels, core::depth iDepth, utils::Size iSize);
            
      bool useCL;
      
      int currentFilterSize;
      int currentDifference;
      
      int nullValue;
      int maxFilterSize;
       
      int numChannels;
      utils::Size size;
      core::depth depth;
 
      std::vector<TemporalSmoothingCL*> clPointer;     
    };
    
  } // namespace filter
}