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.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 <ICLUtils/Uncopyable.h>
#include <ICLCore/Img.h>
#include <ICLFilter/UnaryOp.h>

#ifdef ICL_HAVE_OPENCL
#include <ICLUtils/CLProgram.h>
#include <ICLUtils/CLKernel.h>
#include <ICLUtils/CLBuffer.h>
#endif

namespace icl{
  namespace filter{

    class ICLFilter_API TemporalSmoothingCL{
      public:


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

      ~TemporalSmoothingCL();


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


      core::Img8u temporalSmoothingC(const 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 ICL_HAVE_OPENCL
      //OpenCL
      float* inputImage1ArrayF;
      float* inputImagesArrayF;
      float* outputImageArrayF;

      unsigned char* inputImage1ArrayC;
      unsigned char* inputImagesArrayC;
      unsigned char* outputImageArrayC;

      float* motionImageArray;


      //OpenCL
      utils::CLProgram program;
      utils::CLKernel kernelTemporalSmoothingFloat;
      utils::CLKernel kernelTemporalSmoothingChar;
      utils::CLKernel kernelCheckRANSAC;
      utils::CLKernel kernelAssignRANSAC;

      //OpenCL buffer
      utils::CLBuffer inputImageBufferF;
      utils::CLBuffer outputImageBufferF;
      utils::CLBuffer inputImageBufferC;
      utils::CLBuffer outputImageBufferC;
      utils::CLBuffer motionImageBuffer;
    #endif

    };

    class ICLFilter_API 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
}