helper_funcs.hpp

Go to the documentation of this file.

#ifndef GF_HELPERFUNCS_HPP
#define GF_HELPERFUNCS_HPP

#include <cassert>

#if defined(__APPLE__) || defined(__MACOSX)
#include <OpenCL/cl.hpp>
#else
#include <CL/cl.hpp>
#endif


namespace GF
{

    bool setProfilingFlag (int argc, char **argv);


    template <typename T>
    uint64_t nextPow2 (T num)
    {
        assert (num >= 0);

        uint64_t pow;
        for (pow = 1; pow < (uint64_t) num; pow <<= 1) ;

        return pow;
    }


    template <typename T>
    void printBuffer (const char *title, T *ptr, uint32_t width, uint32_t height)
    {
        std::cout << title << std::endl;

        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                std::cout << std::setw (3 * sizeof (T)) << +ptr[row * width + col] << " ";
            }
            std::cout << std::endl;
        }

        std::cout << std::endl;
    }


    template <typename T>
    void printBufferF (const char *title, T *ptr, uint32_t width, uint32_t height, uint32_t prec)
    {
        std::ios::fmtflags f (std::cout.flags ());
        std::cout << title << std::endl;
        std::cout << std::fixed << std::setprecision (prec);

        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                std::cout << std::setw (5 + prec) << ptr[row * width + col] << " ";
            }
            std::cout << std::endl;
        }

        std::cout << std::endl;
        std::cout.flags (f);
    }


    template <typename T1, typename T2>
    void cpuTranspose (T1 *in, T2 *out, uint32_t width, uint32_t height)
    {
        for (uint row = 0; row < height; ++row)
            for (uint col = 0; col < width; ++col)
                out[col * height + row] = in[row * width + col];
    }


    template <typename T>
    void cpuSeparateRGB (T *in, T *r, T *g, T *b, uint32_t pixels)
    {
        for (uint i = 0; i < pixels; ++i)
        {
            r[i] = in[i * 3];
            g[i] = in[i * 3 + 1];
            b[i] = in[i * 3 + 2];
        }
    }


    template <typename T2>
    void cpuSeparateRGB_N_Norm (unsigned char *in, T2 *r, T2 *g, T2 *b, uint32_t pixels)
    {
        for (uint i = 0; i < pixels; ++i)
        {
            r[i] = (T2) in[i * 3] / 255.f;
            g[i] = (T2) in[i * 3 + 1] / 255.f;
            b[i] = (T2) in[i * 3 + 2] / 255.f;
        }
    }


    template <typename T>
    void cpuCombineRGB (T *r, T *g, T *b, T *out, uint32_t pixels)
    {
        for (uint i = 0; i < pixels; ++i)
        {
            out[i * 3]     = r[i];
            out[i * 3 + 1] = g[i];
            out[i * 3 + 2] = b[i];
        }
    }


    template <typename T1>
    void cpuTranspose_N_Scale (T1 *r, T1 *g, T1 *b, unsigned char *out, uint32_t pixels)
    {
        for (uint i = 0; i < pixels; ++i)
        {
            out[i * 3]     = (unsigned char) (r[i] * 255.f);
            out[i * 3 + 1] = (unsigned char) (g[i] * 255.f);
            out[i * 3 + 2] = (unsigned char) (b[i] * 255.f);
        }
    }


    template <typename T>
    void cpuDepthTo3D (T *depth, cl_float4 *pCloud, uint32_t width, uint32_t height, float f)
    {
        for (uint row = 0; row < height; ++row)
        {
            for (uint col = 0; col < width; ++col)
            {   
                T d = depth[row * width + col];
                pCloud[row * width + col] = { (col - (width - 1) / 2.f) * (float) d / f,
                                              (row - (height - 1) / 2.f) * (float) d / f,
                                              (float) d, 1.f };
            }
        }
    }


    template <typename T>
    void cpuRGBDTo8D (T *D, T *R, T *G, T *B, cl_float8 *points, uint32_t width, uint32_t height, float f, bool rgbNorm)
    {
        for (uint row = 0; row < height; ++row)
        {
            for (uint col = 0; col < width; ++col)
            {
                int i = row * width + col;

                T d = D[i];
                T r = R[i];
                T g = G[i];
                T b = B[i];

                if (rgbNorm)
                {
                    T sum_ = r + g + b;
                    T factor = (sum_ == 0.0) ? 0.0 : 1.0 / sum_;
                    r *= factor;
                    g *= factor;
                    b *= factor;
                }

                points[i] = { (col - (width - 1) / 2.f) * (float) d / f,
                              (row - (height - 1) / 2.f) * (float) d / f,
                              (float) d, 1.f, r, g, b, 1.f };
            }
        }
    }


    template <typename T>
    void cpuSplitPC8D (T *pc8d, T *pc4d, T *rgba, uint32_t n)
    {
        for (uint k = 0; k < n; ++k)
        {
            cl_float *point = pc8d + (k << 3);

            for (uint j = 0; j < 4; ++j)
            {
                pc4d[(k << 2) + j] = point[j];
                rgba[(k << 2) + j] = point[4 + j];
            }
        }
    }


    template <typename T>
    void cpuRGBNorm (T *in, T *out, uint32_t width, uint32_t height)
    {
        for (uint row = 0; row < height; ++row)
        {
            for (uint col = 0; col < width; ++col)
            {   
                uint rank = (row * width + col) * 3;
                T sum_ = in[rank] + in[rank+1] + in[rank+2];
                T factor = (sum_ == 0) ? 0.0 : 1.0 / sum_;
                out[rank] = (T) (factor * in[rank]);
                out[rank+1] = (T) (factor * in[rank+1]); 
                out[rank+2] = (T) (factor * in[rank+2]);
            }
        }
    }


    template <typename T>
    void cpuScan (T *in, T *out, uint32_t width, uint32_t height)
    {
        // Initialize the first element of each row
        for (uint32_t row = 0; row < height; ++row)
            out[row * width] = in[row * width];
        // Perform the scan
        for (uint32_t row = 0; row < height; ++row)
            for (uint32_t col = 1; col < width; ++col)
                out[row * width + col] = out[row * width + col - 1] + in[row * width + col];
    }


    template <typename T>
    void cpuSAT (T *in, T *out, uint32_t width, uint32_t height)
    {
        // Initialize the first element of each row
        for (uint32_t row = 0; row < height; ++row)
            out[row * width] = in[row * width];
        // Perform a scan on the rows
        for (uint32_t row = 0; row < height; ++row)
            for (uint32_t col = 1; col < width; ++col)
                out[row * width + col] = out[row * width + col - 1] + in[row * width + col];
        // Perform a scan on the columns
        for (uint32_t col = 0; col < width; ++col)
            for (uint32_t row = 1; row < height; ++row)
                out[row * width + col] = out[(row - 1) * width + col] + out[row * width + col];
    }


    template <typename T>
    void cpuBoxFilter (T *in, T *out, int width, int height, int radius)
    {
        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                T sum = 0.f;
                int n = 0;
                int ix, iy;

                for (int fRow = -radius; fRow <= radius; ++fRow)
                {
                    for (int fCol = -radius; fCol <= radius; ++fCol)
                    {
                        ix = col + fCol;
                        iy = row + fRow;

                        if ((ix >= 0) && (iy >= 0) && (ix < width) && (iy < height))
                        {
                            sum += in[iy * width + ix];
                            n++;
                        }
                    }
                }

                out[row * width + col] = sum / (T) n;
            }
        }
    }


    template <typename T>
    void cpuMult (T *a, T *b, T *out, int width, int height)
    {
        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                int idx = row * width + col;
                out[idx] = a[idx] * b[idx];
            }
        }
    }


    template <typename T>
    void cpuPown (T *in, T *out, int width, int height, int n)
    {
        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                int idx = row * width + col;
                out[idx] = pow (in[idx], n);
            }
        }
    }


    template <typename T>
    void cpuGuidedFilter (T *p, T *q, int width, int height, int radius, float eps)
    {
        int pixels = width * height;
        T *mean_p = new T[pixels];
        T *p2 = new T[pixels];
        T *mean_p2 = new T[pixels];
        T *a = new T[pixels];
        T *b = new T[pixels];
        T *mean_a = new T[pixels];
        T *mean_b = new T[pixels];

        cpuBoxFilter (p, mean_p, width, height, radius);
        cpuPown (p, p2, width, height, 2);
        cpuBoxFilter (p2, mean_p2, width, height, radius);

        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                int idx = row * width + col;
                T var = mean_p2[idx] - mean_p[idx] * mean_p[idx];
                a[idx] = var / (var + eps);
                b[idx] = (1 - a[idx]) * mean_p[idx];
            }
        }

        cpuBoxFilter (a, mean_a, width, height, radius);
        cpuBoxFilter (b, mean_b, width, height, radius);

        for (int row = 0; row < height; ++row)
        {
            for (int col = 0; col < width; ++col)
            {
                int idx = row * width + col;
                q[idx] = mean_a[idx] * p[idx] + mean_b[idx];
            }
        }
    }

}

#endif  // GF_HELPERFUNCS_HPP