imgproc_aux.hpp

Go to the documentation of this file.

#pragma once

#ifdef USE_OPENCV

#ifdef _MSC_VER
#include <mycv.hpp> // for OpenCV
#pragma comment(lib, OPENCV_LIB_EXPAND("core"))
#pragma comment(lib, OPENCV_LIB_EXPAND("imgproc"))
#pragma comment(lib, OPENCV_LIB_EXPAND("highgui"))
#pragma comment(lib, OPENCV_LIB_EXPAND("video"))
#else
#include <opencv2/opencv.hpp>
#endif

#endif

#include <armadillo>
using namespace arma;

#include "arma_ext.hpp"

namespace auxiliary
{
    template <typename T>
    class Size : public arma::Col<T>::template fixed<2>
    {
    public:
        
        Size(T w = 0, T h = 0)
        {
            this->at(0) = w;
            this->at(1) = h;
        }
        
        T width() const     { return this->at(0); }
        T height() const    { return this->at(1); }
        
        T& width()          { return this->at(0); }
        T& height()         { return this->at(1); }
    };
    
    template <typename T>
    class Image : public Mat<T>
    {
    public:
        typedef T                                   elem_type;  
        typedef typename get_pod_type<T>::result    pod_type;   

        typedef arma::uword                         size_type;

        Image(): Mat<T>() {}

        Image(const Mat<T>& m): Mat<T>(m) {}

        Image(const size_type width, const size_type height) : Mat<T>(height, width) {}
        
        template <typename DT>
        Image(const Mat<DT>& m): Mat<T>(m.n_rows, m.n_cols)
        {
            T* ptr = this->memptr();
            // type conversion
#if defined(USE_PPL)
            concurrency::parallel_for(size_type(0), m.n_elem, [&](size_type i) {
#elif defined(USE_OPENMP)
    #pragma omp parallel for
            for (int si = 0 ; si < (int)m.n_elem ; si++) {
                size_type i = (size_type)si;
#else
            for (size_type i = 0 ; i < m.n_elem ; i++)
#endif
                ptr[i] = arma_ext::saturate_cast<T>(m(i));
#if defined(USE_PPL)
            });
#elif defined(USE_OPENMP)
            }
#endif
        }

        void release() {}

        inline size_type width() const { return this->n_cols; }

        inline size_type height() const { return this->n_rows; }

        inline void resize(size_type width, size_type height)
        {
            this->set_size(height, width);
        }

        // Operator overloading
        operator Mat<T>&()
        {
            return static_cast<Mat<T> >(*this);
        }
    };

    template <typename pixel_type, typename vec_type>
    static arma::Mat<pixel_type> getRectSubPix(const Image<pixel_type>& img, Size<arma_ext::uword> patchsize, const vec_type center)
    {
        typedef typename vec_type::elem_type elem_type;
        typedef typename arma_ext::size_type size_type;
        arma::Mat<pixel_type> out(patchsize.height(), patchsize.width());

#ifdef __VXWORKS__
        typename arma::Col<elem_type>::template fixed<2> center_;
        center_[0] = center[0];
        center_[1] = center[1];
#else
        typename arma::Col<elem_type>::template fixed<2> center_ = center;
#endif

        center_[0] -= (elem_type)(patchsize.width() - 1) * (elem_type)0.5;
        center_[1] -= (elem_type)(patchsize.height() - 1) * (elem_type)0.5;

        int ipx = (int)std::floor(center_[0]);
        int ipy = (int)std::floor(center_[1]);

        elem_type ox = center_[0] - (elem_type)ipx;
        elem_type oy = center_[1] - (elem_type)ipy;
        
        elem_type a11 = (1 - ox) * (1 - oy),
                  a12 =      ox  * (1 - oy),
                  a21 = (1 - ox) * oy,
                  a22 =      ox  * oy;

        if (0 <= ipx && ipx + patchsize.width() < img.n_cols &&
            0 <= ipy && ipy + patchsize.height() < img.n_rows) {
            // extracted rectangle is totally inside the image
#ifdef USE_PPL
            concurrency::parallel_for(arma_ext::size_type(0), out.n_cols, [&](arma_ext::size_type j) {
#elif defined(USE_OPENMP)
    #pragma omp parallel for
            for (int sj = 0 ; sj < (int)out.n_cols ; sj++) {
                size_type j = (size_type)sj;
#else
            for (size_type j = 0 ; j < out.n_cols ; j++) {
#endif
                pixel_type* ptr = out.colptr(j);
                const pixel_type* src = img.colptr(ipx + j) + ipy;
                size_type i;
                for (i = 0 ; i < out.n_rows ; i++) {
                    // bilinear interpolation
                    ptr[i] = arma_ext::saturate_cast<pixel_type>((elem_type)src[i                 ] * a11 +
                            (elem_type)src[i + 1             ] * a21 +
                            (elem_type)src[i + img.n_rows    ] * a12 +
                            (elem_type)src[i + img.n_rows + 1] * a22);
                }
#ifdef USE_PPL
            });
#else
            }
#endif
        } else {
            arma::ivec4 r;

            // adjust rectangle
            int sox = 0, soy = 0;

            // -------- begin --------
            if (ipx >= 0) {
                sox += ipx; // + ipx
                r[0] = 0;
            } else {
                r[0] = -ipx;
                if (r[0] > (int)patchsize.width())
                    r[0] = patchsize.width();
            }
            
            if (ipx + (int)patchsize.width() < (int)img.n_cols)
                r[2] = patchsize.width();
            else {
                r[2] = (int)img.n_cols - ipx - 1;
                if (r[2] < 0) {
                    sox += r(2);    // + width
                    r[2] = 0;
                }
            }

            if (ipy >= 0) {
                soy += ipy; // + ipy
                r[1] = 0;
            } else {
                r[1] = -ipy;
                if (r[1] > (int)patchsize.height())
                    r[1] = patchsize.height();
            }

            if (ipy + (int)patchsize.height() < (int)img.n_rows)
                r[3] = patchsize.height();
            else {
                r[3] = (int)img.n_rows - ipy - 1;
                if (r[3] < 0) {
                    soy += r[3];    // + height
                    r[3] = 0;
                }
            }
            // --------- end ---------

            //soy -= r(1);

            elem_type b1 = (elem_type)1.0 - ox,
                      b2 = ox;

            const pixel_type* src1 = img.colptr(sox) + soy;
            for (size_type j = 0 ; j < out.n_cols ; j++) {
                pixel_type* ptr = out.colptr(j);
                const pixel_type* src2 = src1 + img.n_rows;

                if ((int)j < r[0] || (int)j >= r[2])
                    src2 -= img.n_rows;
                                
                size_type i = 0;
                for (; i < (size_type)r(1) ; i++)
                    ptr[i] = arma_ext::saturate_cast<pixel_type>((elem_type)src1[r[1]] * b1 + (elem_type)src2[r[1]] * b2);

                for ( ; i < (size_type)r(3) ; i++) {
                    // bilinear interpolation
                    ptr[i] = arma_ext::saturate_cast<pixel_type>((elem_type)src1[i    ] * a11 +
                            (elem_type)src1[i + 1] * a21 +
                            (elem_type)src2[i    ] * a12 +
                            (elem_type)src2[i + 1] * a22);
                }

                for ( ; i < out.n_rows ; i++)
                    ptr[i] = arma_ext::saturate_cast<pixel_type>((elem_type)src1[r[3]] * b1 + (elem_type)src2[r[3]] * b2);

                if ((int)j < r[2])
                    src1 = src2;
            }
        }
                                      
        return out;
    }
        
    template <typename pixel_type>
    inline Image<pixel_type> blur(const Image<pixel_type>& img, const mat& h)
    {
        typedef typename Image<pixel_type>::size_type size_type;
        return Image<pixel_type>(arma_ext::conv2(conv_to<mat>::from(img), h, arma_ext::same).eval());
    }

#ifdef USE_OPENCV
    template <typename pixel_type>
    cv::Mat tocvMat(const Image<pixel_type>& img)
    {
        cv::Mat out(img.n_rows, img.n_cols, cv::DataType<pixel_type>::type); 
        Image<pixel_type> t = img.t().eval();
        memcpy(out.data, t.memptr(), sizeof(pixel_type) * t.n_elem);

        //cv::imshow(name, out);
        return out;
    }

    template <typename pixel_type>
    Image<pixel_type>   bgr2gray(const cv::Mat& img)
    {
        arma::Mat<pixel_type> gray(img.cols, img.rows);
        pixel_type* ptr = gray.memptr();
#if 0
        concurrency::parallel_for(0, img.rows, [&](int r) {
        //for (int r = 0 ; r < img.rows ; r++) {
            const uchar* src = img.ptr(r);
            uchar* dst = ptr + gray.n_rows * r;
            for (int c = 0 ; c < img.cols ; c++, src += 3)
                dst[c] = arma_ext::round<uchar>(src[2] * 0.298936021293776 + src[1] * 0.587043074451121 + src[0] * 0.114020904255103);
        //}
        });
#else
        cv::Mat bw;
        cv::cvtColor(img, bw, CV_BGR2GRAY);
        memcpy(ptr, bw.data, sizeof(pixel_type) * bw.total());
#endif

        return Image<pixel_type>(gray.t());
    }
#endif
}