algorithms.hpp

Go to the documentation of this file.

#ifndef GF_ALGORITHMS_HPP
#define GF_ALGORITHMS_HPP

#include <CLUtils.hpp>
#include <GuidedFilter/common.hpp>
#include <GuidedFilter/math.hpp>


namespace cl_algo
{
namespace GF
{

    enum class SeparateRGBConfig : uint8_t
    {
        FLOAT_FLOAT,  
        UCHAR_FLOAT   
    };


    template <SeparateRGBConfig C>
    class SeparateRGB;


    template <>
    class SeparateRGB<SeparateRGBConfig::FLOAT_FLOAT>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,     
            H_OUT_R,  
            H_OUT_G,  
            H_OUT_B,  
            D_IN,     
            D_OUT_R,  
            D_OUT_G,  
            D_OUT_B   
        };

        SeparateRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (SeparateRGB::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (SeparateRGB::Memory mem = SeparateRGB::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (SeparateRGB::Memory mem = SeparateRGB::Memory::H_OUT_R, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrIn;  
        cl_float *hPtrOutR;  
        cl_float *hPtrOutG;  
        cl_float *hPtrOutB;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        size_t wgMultiple;
        unsigned int width, height;
        unsigned int bufferInSize, bufferOutSize;
        cl::Buffer hBufferIn, hBufferOutR, hBufferOutG, hBufferOutB;
        cl::Buffer dBufferIn, dBufferOutR, dBufferOutG, dBufferOutB;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    template <>
    class SeparateRGB<SeparateRGBConfig::UCHAR_FLOAT>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,     
            H_OUT_R,  
            H_OUT_G,  
            H_OUT_B,  
            D_IN,     
            D_OUT_R,  
            D_OUT_G,  
            D_OUT_B   
        };

        SeparateRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (SeparateRGB::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (SeparateRGB::Memory mem = SeparateRGB::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (SeparateRGB::Memory mem = SeparateRGB::Memory::H_OUT_R, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_uchar *hPtrIn;  
        cl_float *hPtrOutR;  
        cl_float *hPtrOutG;  
        cl_float *hPtrOutB;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        size_t wgMultiple;
        unsigned int width, height;
        unsigned int bufferInSize, bufferOutSize;
        cl::Buffer hBufferIn, hBufferOutR, hBufferOutG, hBufferOutB;
        cl::Buffer dBufferIn, dBufferOutR, dBufferOutG, dBufferOutB;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    enum class CombineRGBConfig : uint8_t
    {
        FLOAT_FLOAT,  
        FLOAT_UCHAR   
    };


    template <CombineRGBConfig C>
    class CombineRGB;


    template <>
    class CombineRGB<CombineRGBConfig::FLOAT_FLOAT>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN_R,  
            H_IN_G,  
            H_IN_B,  
            H_OUT,   
            D_IN_R,  
            D_IN_G,  
            D_IN_B,  
            D_OUT    
        };

        CombineRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (CombineRGB::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (CombineRGB::Memory mem = CombineRGB::Memory::D_IN_R, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (CombineRGB::Memory mem = CombineRGB::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrInR;  
        cl_float *hPtrInG;  
        cl_float *hPtrInB;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        size_t wgMultiple;
        unsigned int width, height;
        unsigned int bufferInSize, bufferOutSize;
        cl::Buffer hBufferInR, hBufferInG, hBufferInB, hBufferOut;
        cl::Buffer dBufferInR, dBufferInG, dBufferInB, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    template <>
    class CombineRGB<CombineRGBConfig::FLOAT_UCHAR>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN_R,  
            H_IN_G,  
            H_IN_B,  
            H_OUT,   
            D_IN_R,  
            D_IN_G,  
            D_IN_B,  
            D_OUT    
        };

        CombineRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (CombineRGB::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (CombineRGB::Memory mem = CombineRGB::Memory::D_IN_R, 
                    void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (CombineRGB::Memory mem = CombineRGB::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrInR;  
        cl_float *hPtrInG;  
        cl_float *hPtrInB;  
        cl_uchar *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        size_t wgMultiple;
        unsigned int width, height;
        unsigned int bufferInSize, bufferOutSize;
        cl::Buffer hBufferInR, hBufferInG, hBufferInB, hBufferOut;
        cl::Buffer dBufferInR, dBufferInG, dBufferInB, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    enum class DepthConfig : uint8_t
    {
        USHORT_FLOAT  
    };


    template <DepthConfig C>
    class Depth;


    template <>
    class Depth<DepthConfig::USHORT_FLOAT>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        Depth (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (Depth::Memory mem);
        void init (unsigned int _width, unsigned int _height, float _scaling = 1.f, Staging _staging = Staging::IO);
        void write (Depth::Memory mem = Depth::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (Depth::Memory mem = Depth::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        float getScaling ();
        void setScaling (float _scaling);

        cl_ushort *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int length;
        unsigned int bufferInSize, bufferOutSize;
        float scaling;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    class DepthTo3D
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        DepthTo3D (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (DepthTo3D::Memory mem);
        void init (unsigned int _width, unsigned int _height, 
                   float _f, float _scaling = 1.f, Staging _staging = Staging::IO);
        void write (DepthTo3D::Memory mem = DepthTo3D::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (DepthTo3D::Memory mem = DepthTo3D::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        float getFocalLength ();
        void setFocalLength (float _f);
        float getScaling ();
        void setScaling (float _scaling);

        cl_float *hPtrIn;  
        cl_float4 *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int width, height;
        unsigned int bufferInSize, bufferOutSize;
        float f, scaling;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    class RGBDTo8D
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN_D,  
            H_IN_R,  
            H_IN_G,  
            H_IN_B,  
            H_OUT,   
            D_IN_D,  
            D_IN_R,  
            D_IN_G,  
            D_IN_B,  
            D_OUT    
        };

        RGBDTo8D (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (RGBDTo8D::Memory mem);
        void init (unsigned int _width, unsigned int _height, 
                   float _f, float _scaling = 1.f, int _rgbNorm = 0, Staging _staging = Staging::IO);
        void write (RGBDTo8D::Memory mem = RGBDTo8D::Memory::D_IN_D, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (RGBDTo8D::Memory mem = RGBDTo8D::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        float getFocalLength ();
        void setFocalLength (float _f);
        float getScaling ();
        void setScaling (float _scaling);
        int getRGBNorm ();
        void setRGBNorm (int _rgbNorm);

        cl_float *hPtrInD;  
        cl_float *hPtrInR;  
        cl_float *hPtrInG;  
        cl_float *hPtrInB;  
        cl_float8 *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        size_t wgMultiple;
        unsigned int width, height, points;
        unsigned int bufferInSize, bufferOutSize;
        float f, scaling;
        int rgbNorm;
        cl::Buffer hBufferInD, hBufferInR, hBufferInG, hBufferInB, hBufferOut;
        cl::Buffer dBufferInD, dBufferInR, dBufferInG, dBufferInB, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    class SplitPC8D
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,        
            H_OUT_PC4D,  
            H_OUT_RGBA,  
            D_IN,        
            D_OUT_PC4D,  
            D_OUT_RGBA   
        };

        SplitPC8D (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (SplitPC8D::Memory mem);
        void init (unsigned int _n, unsigned int _offset = 0, Staging _staging = Staging::IO);
        void write (SplitPC8D::Memory mem = SplitPC8D::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (SplitPC8D::Memory mem = SplitPC8D::Memory::H_OUT_PC4D, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        unsigned int getOffset ();
        void setOffset (unsigned int _offset);

        cl_float *hPtrIn;       
        cl_float *hPtrOutPC4D;  
        cl_float *hPtrOutRGBA;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int n, offset;
        unsigned int bufferInSize, bufferOutSize;
        cl::Buffer hBufferIn, hBufferOutPC4D, hBufferOutRGBA;
        cl::Buffer dBufferIn, dBufferOutPC4D, dBufferOutRGBA;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    class RGBNorm
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        RGBNorm (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (RGBNorm::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (RGBNorm::Memory mem = RGBNorm::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (RGBNorm::Memory mem = RGBNorm::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global;
        Staging staging;
        unsigned int width, height, bufferSize;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, cl::NullRange, events, &timer.event ());
            queue.flush (); timer.wait ();
            
            return timer.duration ();
        }

    };


    class Scan
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,    
            H_OUT,   
            D_IN,    
            D_SUMS,  
            D_OUT    
        };

        Scan (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (Scan::Memory mem);
        void init (unsigned int _width, unsigned int _height, float _scaling = 1.f, Staging _staging = Staging::IO);
        void write (Scan::Memory mem = Scan::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (Scan::Memory mem = Scan::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        float getScaling ();
        void setScaling (float _scaling);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernelScan, kernelSumsScan, kernelAddSums;
        cl::NDRange globalScan, globalSumsScan, localScan;
        cl::NDRange globalAddSums, localAddSums, offsetAddSums;
        Staging staging;
        size_t wgMultiple, wgXdim;
        unsigned int width, height, bufferSize, bufferSumsSize;
        float scaling;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut, dBufferSums;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            double pTime;

            if (wgXdim == 1)
            {
                queue.enqueueNDRangeKernel (
                    kernelScan, cl::NullRange, globalScan, localScan, events, &timer.event ());
                queue.flush (); timer.wait ();
                pTime = timer.duration ();
            }
            else
            {
                queue.enqueueNDRangeKernel (
                    kernelScan, cl::NullRange, globalScan, localScan, events, &timer.event ());
                queue.flush (); timer.wait ();
                pTime = timer.duration ();

                queue.enqueueNDRangeKernel (
                    kernelSumsScan, cl::NullRange, globalSumsScan, localScan, nullptr, &timer.event ());
                queue.flush (); timer.wait ();
                pTime += timer.duration ();

                queue.enqueueNDRangeKernel (
                    kernelAddSums, offsetAddSums, globalAddSums, localAddSums, nullptr, &timer.event ());
                queue.flush (); timer.wait ();
                pTime += timer.duration ();
            }

            return pTime;
        }

    };


    class Transpose
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        Transpose (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (Transpose::Memory mem);
        void init (unsigned int _width, unsigned int _height, Staging _staging = Staging::IO);
        void write (Transpose::Memory mem = Transpose::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (Transpose::Memory mem = Transpose::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        unsigned int width, height, bufferSize;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (kernel, cl::NullRange, global, local, events, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    class SAT
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        SAT (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info, bool _transposed = true);
        cl::Memory& get (SAT::Memory mem);
        void init (unsigned int _width, unsigned int _height, float _scaling = 1.f, Staging _staging = Staging::IO);
        void write (SAT::Memory mem = SAT::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (SAT::Memory mem = SAT::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        float getScaling ();
        void setScaling (float _scaling);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        Scan scanRows, scanColumns;
        Transpose transpose1, transpose2;
        Staging staging;
        unsigned int width, height, bufferSize;
        float scaling;
        bool transposed;
        cl::Buffer hBufferIn, hBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            double pTime;

            pTime = scanRows.run (timer, events);
            pTime += transpose1.run (timer);
            pTime += scanColumns.run (timer);
            
            if (!transposed)
                pTime += transpose2.run (timer);

            return pTime;
        }

    };


    class BoxFilterSAT
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        BoxFilterSAT (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (BoxFilterSAT::Memory mem);
        void init (unsigned int _width, unsigned int _height, 
                   int _radius, float _scaling = 1e-4f, Staging _staging = Staging::IO);
        void write (BoxFilterSAT::Memory mem = BoxFilterSAT::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (BoxFilterSAT::Memory mem = BoxFilterSAT::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        int getRadius ();
        void setRadius (int _radius);
        float getScaling ();
        void setScaling (float _scaling);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        static const unsigned int lXdim = 16;
        static const unsigned int lYdim = 16;
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        unsigned int width, height, bufferSize;
        int radius;
        float scaling;
        SAT sat;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            double pTime;

            pTime = sat.run (timer, events);
            
            queue.enqueueNDRangeKernel (
                kernel, cl::NullRange, global, local, nullptr, &timer.event ());
            queue.flush (); timer.wait ();
            pTime += timer.duration ();

            return pTime;
        }

    };


    class BoxFilter
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT   
        };

        BoxFilter (clutils::CLEnv &_env, clutils::CLEnvInfo<1> _info);
        cl::Memory& get (BoxFilter::Memory mem);
        void init (unsigned int _width, unsigned int _height, int _radius, Staging _staging = Staging::IO);
        void write (BoxFilter::Memory mem = BoxFilter::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (BoxFilter::Memory mem = BoxFilter::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        int getRadius ();
        void setRadius (int _radius);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        static const unsigned int lXdim = 16;
        static const unsigned int lYdim = 16;
        clutils::CLEnv &env;
        clutils::CLEnvInfo<1> info;
        cl::Context context;
        cl::CommandQueue queue;
        cl::Kernel kernel;
        cl::NDRange global, local;
        Staging staging;
        unsigned int width, height, bufferSize;
        int radius;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            queue.enqueueNDRangeKernel (
                kernel, cl::NullRange, global, local, nullptr, &timer.event ());
            queue.flush (); timer.wait ();

            return timer.duration ();
        }

    };


    enum class GuidedFilterConfig : uint8_t
    {
        I_NEQ_P,  
        I_EQ_P    
    };


    template <GuidedFilterConfig Ip>
    class GuidedFilter;


    template <>
    class GuidedFilter<GuidedFilterConfig::I_EQ_P>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN,   
            H_OUT,  
            D_IN,   
            D_OUT,  
            D_A,    
            D_B     
        };

        GuidedFilter (clutils::CLEnv &_env, clutils::CLEnvInfo<2> _info);
        cl::Memory& get (GuidedFilter::Memory mem);
        void init (unsigned int _width, unsigned int _height, int _radius, float _eps, int _zero_out = 0, 
                   float _boxScaling = 1e-4f, float _outputScaling = 1.f, Staging _staging = Staging::IO);
        void write (GuidedFilter::Memory mem = GuidedFilter::Memory::D_IN, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (GuidedFilter::Memory mem = GuidedFilter::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        int getRadius ();
        void setRadius (int _radius);
        float getEps ();
        void setEps (float _eps);
        float getBoxScaling ();
        void setBoxScaling (float _boxScaling);
        float getOutputScaling ();
        void setOutputScaling (float _outputScaling);
        int getZeroing ();
        void setZeroing (int _zero_out);

        cl_float *hPtrIn;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<2> info;
        cl::Context context;
        cl::CommandQueue queue0;
        BoxFilterSAT mean_p, mean_p2, mean_a, mean_b;
        Math::Pown squared;
        cl::Kernel ab, q;
        cl::NDRange global;
        Staging staging;
        unsigned int width, height, bufferSize;
        int radius; float eps;
        int zero_out;
        float boxScaling, outputScaling;
        cl::Buffer hBufferIn, hBufferOut;
        cl::Buffer dBufferIn, dBufferOut;
        cl::Buffer dBufferOutA, dBufferOutB;
        cl::Event p2Event, abEvent, mbEvent;
        std::vector<cl::Event> waitListAB, waitListMB, waitListQ;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            double pTime;

            pTime = mean_p.run (timer, events);
            pTime += squared.run (timer);
            pTime += mean_p2.run (timer);
            
            queue0.enqueueNDRangeKernel (ab, cl::NullRange, global, cl::NullRange, nullptr, &timer.event ());
            queue0.flush (); timer.wait ();
            pTime += timer.duration ();

            pTime += mean_a.run (timer);
            pTime += mean_b.run (timer);
            
            queue0.enqueueNDRangeKernel (q, cl::NullRange, global, cl::NullRange, nullptr, &timer.event ());
            queue0.flush (); timer.wait ();
            pTime += timer.duration ();

            return pTime;
        }

    };


    template <>
    class GuidedFilter<GuidedFilterConfig::I_NEQ_P>
    {
    public:
        enum class Memory : uint8_t
        {
            H_IN_I,    
            H_IN_P,    
            H_OUT,     
            D_IN_I,    
            D_IN_P,    
            D_OUT,     
            D_VAR_I,   
            D_COV_IP,  
            D_A,       
            D_B        
        };

        GuidedFilter (clutils::CLEnv &_env, clutils::CLEnvInfo<2> _info);
        cl::Memory& get (GuidedFilter::Memory mem);
        void init (unsigned int _width, unsigned int _height, int _radius, float _eps, 
                   int _zero_out = 0, float _boxScaling = 1e-4f, Staging _staging = Staging::IO);
        void write (GuidedFilter::Memory mem = GuidedFilter::Memory::D_IN_I, void *ptr = nullptr, bool block = CL_FALSE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void* read (GuidedFilter::Memory mem = GuidedFilter::Memory::H_OUT, bool block = CL_TRUE, 
                    const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
        int getRadius ();
        void setRadius (int _radius);
        float getEps ();
        void setEps (float _eps);
        float getBoxScaling ();
        void setBoxScaling (float _boxScaling);
        int getZeroing ();
        void setZeroing (int _zero_out);

        cl_float *hPtrInI;  
        cl_float *hPtrInP;  
        cl_float *hPtrOut;  
    private:
        clutils::CLEnv &env;
        clutils::CLEnvInfo<2> info;
        cl::Context context;
        cl::CommandQueue queue0;
        BoxFilterSAT mean_I, mean_p, corr_I, corr_Ip, mean_a, mean_b;
        Math::Mult mult_II, mult_Ip;
        cl::Kernel var, ab, q;
        cl::NDRange global;
        Staging staging;
        unsigned int width, height, bufferSize;
        int radius; float eps;
        int zero_out;
        float boxScaling;
        cl::Buffer hBufferInI, hBufferInP, hBufferOut;
        cl::Buffer dBufferInI, dBufferInP, dBufferOut;
        cl::Buffer dBufferOutVarI, dBufferOutCovIp;
        cl::Buffer dBufferOutA, dBufferOutB;
        cl::Event corrIpEvent, abEvent, mbEvent;
        std::vector<cl::Event> waitListVar, waitListMB, waitListQ;

    public:
        template <typename period>
        double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
        {
            double pTime;

            pTime = mean_I.run (timer, events);
            pTime += mean_p.run (timer, events);
            pTime += mult_II.run (timer, events);
            pTime += mult_Ip.run (timer, events);
            pTime += corr_I.run (timer);
            pTime += corr_Ip.run (timer);
            
            queue0.enqueueNDRangeKernel (var, cl::NullRange, global, cl::NullRange, nullptr, &timer.event ());
            queue0.flush (); timer.wait ();
            pTime += timer.duration ();

            queue0.enqueueNDRangeKernel (ab, cl::NullRange, global, cl::NullRange, nullptr, &timer.event ());
            queue0.flush (); timer.wait ();
            pTime += timer.duration ();

            pTime += mean_a.run (timer);
            pTime += mean_b.run (timer);
            
            queue0.enqueueNDRangeKernel (q, cl::NullRange, global, cl::NullRange, nullptr, &timer.event ());
            queue0.flush (); timer.wait ();
            pTime += timer.duration ();

            return pTime;
        }

    };


    namespace Kinect
    {

        enum class GuidedFilterRGBConfig : uint8_t
        {
            INTERLEAVED_FLOAT,  
            SEPARATED           
        };


        template <GuidedFilterRGBConfig C>
        class GuidedFilterRGB;


        template <>
        class GuidedFilterRGB<GuidedFilterRGBConfig::SEPARATED>
        {
        public:
            enum class Memory : uint8_t
            {
                H_IN,      
                H_OUT_R,   
                H_OUT_G,   
                H_OUT_B,   
                D_IN,      
                D_INTR_R,  
                D_INTR_G,  
                D_INTR_B,  
                D_OUT_R,   
                D_OUT_G,   
                D_OUT_B    
            };

            GuidedFilterRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<2> _info);
            cl::Memory& get (GuidedFilterRGB::Memory mem);
            void init (unsigned int _width, unsigned int _height, 
                       int _radius, float _eps, Staging _staging = Staging::IO);
            void write (GuidedFilterRGB::Memory mem = GuidedFilterRGB::Memory::D_IN, void *ptr = nullptr, 
                        bool block = CL_FALSE, const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void* read (GuidedFilterRGB::Memory mem = GuidedFilterRGB::Memory::H_OUT_R, bool block = CL_TRUE, 
                        const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            int getRadius ();
            void setRadius (int _radius);
            float getEps ();
            void setEps (float _eps);

            cl_uchar *hPtrIn;  
            cl_float *hPtrOutR;  
            cl_float *hPtrOutG;  
            cl_float *hPtrOutB;  
        private:
            clutils::CLEnv &env;
            clutils::CLEnvInfo<2> info;
            cl::Context context;
            cl::CommandQueue queue0;
            SeparateRGB<SeparateRGBConfig::UCHAR_FLOAT> sRGB;
            GuidedFilter<GuidedFilterConfig::I_EQ_P> gfR, gfG, gfB;
            Staging staging;
            unsigned int width, height;
            unsigned int bufferInSize, bufferOutSize;
            int radius; float eps;
            cl::Buffer hBufferIn, hBufferOutR, hBufferOutG, hBufferOutB;
            cl::Buffer dBufferIn, dBufferOutR, dBufferOutG, dBufferOutB;
            cl::Event sEvent; std::vector<cl::Event> waitList;

        public:
            template <typename period>
            double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
            {
                double pTime;

                pTime = sRGB.run (timer, events);
                pTime += gfR.run (timer);
                pTime += gfG.run (timer);
                pTime += gfB.run (timer);

                return pTime;
            }

        };


        template <>
        class GuidedFilterRGB<GuidedFilterRGBConfig::INTERLEAVED_FLOAT>
        {
        public:
            enum class Memory : uint8_t
            {
                H_IN,      
                H_OUT,     
                D_IN,      
                D_INTR_R,  
                D_INTR_G,  
                D_INTR_B,  
                D_OUT      
            };

            GuidedFilterRGB (clutils::CLEnv &_env, clutils::CLEnvInfo<2> _info);
            cl::Memory& get (GuidedFilterRGB::Memory mem);
            void init (unsigned int _width, unsigned int _height, 
                       int _radius, float _eps, Staging _staging = Staging::IO);
            void write (GuidedFilterRGB::Memory mem = GuidedFilterRGB::Memory::D_IN, void *ptr = nullptr, 
                        bool block = CL_FALSE, const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void* read (GuidedFilterRGB::Memory mem = GuidedFilterRGB::Memory::H_OUT, bool block = CL_TRUE, 
                        const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            int getRadius ();
            void setRadius (int _radius);
            float getEps ();
            void setEps (float _eps);

            cl_uchar *hPtrIn;  
            cl_float *hPtrOut;  
        private:
            clutils::CLEnv &env;
            clutils::CLEnvInfo<2> info;
            cl::Context context;
            cl::CommandQueue queue0;
            SeparateRGB<SeparateRGBConfig::UCHAR_FLOAT> sRGB;
            GuidedFilter<GuidedFilterConfig::I_EQ_P> gfR, gfG, gfB;
            CombineRGB<CombineRGBConfig::FLOAT_FLOAT> cRGB;
            Staging staging;
            unsigned int width, height;
            unsigned int bufferInSize, bufferOutSize;
            int radius; float eps;
            cl::Buffer hBufferIn, hBufferOut;
            cl::Buffer dBufferIn, dBufferOut;
            cl::Event sEvent; std::vector<cl::Event> waitList;

        public:
            template <typename period>
            double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
            {
                double pTime;

                pTime = sRGB.run (timer, events);
                pTime += gfR.run (timer);
                pTime += gfG.run (timer);
                pTime += gfB.run (timer);
                pTime = cRGB.run (timer);

                return pTime;
            }

        };


        class GuidedFilterDepth
        {
        public:
            enum class Memory : uint8_t
            {
                H_IN,   
                H_OUT,  
                D_IN,   
                D_OUT   
            };

            GuidedFilterDepth (clutils::CLEnv &_env, clutils::CLEnvInfo<2> _info);
            cl::Memory& get (GuidedFilterDepth::Memory mem);
            void init (unsigned int _width, unsigned int _height, 
                       int _radius, float _eps, float _dScaling = 1e-3f, Staging _staging = Staging::IO);
            void write (GuidedFilterDepth::Memory mem = GuidedFilterDepth::Memory::D_IN, 
                        void *ptr = nullptr, bool block = CL_FALSE, 
                        const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void* read (GuidedFilterDepth::Memory mem = GuidedFilterDepth::Memory::H_OUT, bool block = CL_TRUE, 
                        const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            void run (const std::vector<cl::Event> *events = nullptr, cl::Event *event = nullptr);
            int getRadius ();
            void setRadius (int _radius);
            float getEps ();
            void setEps (float _eps);
            float getDScaling ();
            void setDScaling (float _dScaling);

            cl_ushort *hPtrIn;  
            cl_float *hPtrOut;  
        private:
            clutils::CLEnv &env;
            clutils::CLEnvInfo<2> info;
            cl::Context context;
            cl::CommandQueue queue0;
            Depth<DepthConfig::USHORT_FLOAT> depth;
            GuidedFilter<GuidedFilterConfig::I_EQ_P> gf;
            Staging staging;
            unsigned int width, height;
            unsigned int bufferInSize, bufferOutSize;
            int radius; float eps; float dScaling;
            cl::Buffer hBufferIn, hBufferOut;
            cl::Buffer dBufferIn, dBufferOut;
            cl::Event dEvent; std::vector<cl::Event> waitList;

        public:
            template <typename period>
            double run (clutils::GPUTimer<period> &timer, const std::vector<cl::Event> *events = nullptr)
            {
                double pTime;

                pTime = depth.run (timer, events);
                pTime += gf.run (timer);

                return pTime;
            }

        };

    }

}
}

#endif  // GF_ALGORITHMS_HPP