opencv.h

Go to the documentation of this file.

#ifndef MF_OPENCV_H_
#define MF_OPENCV_H_

#include <opencv2/opencv.hpp>

#include "color.h"
#include "ndarray/ndcoord.h"
#include "ndarray/ndarray.h"

namespace cv { // in OpenCV namespace
    template<>
    class DataType<::mf::rgb_color> {
    public:
        using value_type = mf::rgb_color;
        using work_type = int;
        using channel_type = uchar;
        enum {
            generic_type = 0,
            depth = DataDepth<channel_type>::value,
            channels = 3,
            fmt = ((channels - 1)<<8) + DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
        using vec_type = Vec<channel_type, channels>;
    };
    
    template<>
    class DataType<::mf::ycbcr_color> {
    public:
        using value_type = mf::ycbcr_color;
        using work_type = int;
        using channel_type = uchar;
        enum {
            generic_type = 0,
            depth = DataDepth<channel_type>::fmt,
            channels = 3,
            fmt = ((channels - 1)<<8) + DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
        using vec_type = Vec<channel_type, channels>;
    };
}


namespace mf {


/*

template<std::size_t Dim, typename Elem>
auto to_opencv_mat(const ndarray_view<Dim, Elem>& vw) {
    using opencv_type = cv::DataType<Elem>;
    using channel_type = typename opencv_type::channel_type;

    int sizes[Dim];
    for(std::ptrdiff_t i = 0; i < Dim; ++i) sizes[i] = vw.shape()[i];

/*  if(vw.has_default_strides()) {
        cv::Mat mat(
            Dim,
            sizes,
            opencv_type::type,
            reinterpret_cast<void*>(vw.start())
        );
        cv::Mat_<Elem> mat_(mat);
        return mat_;

    } else {*/
        ndarray<Dim, Elem> arr(vw);
        cv::Mat mat(
            Dim,
            sizes,
            opencv_type::type,
            reinterpret_cast<void*>(arr.start())
        );
        cv::Mat_<Elem> mat_(mat);
        cv::Mat_<Elem> mat_copy_;
        mat_.copyTo(mat_copy_);
        return mat_copy_;
        

}


template<std::size_t Dim, typename Elem>
bool copy_less_convertible_to_opencv_mat(const ndarray_view<Dim, Elem>& vw) {
    return vw.has_default_strides();
}



template<std::size_t Dim, typename T>
auto to_ndarray_view(const cv::Mat_<T>& mat) {
    T* start = reinterpret_cast<T*>(mat.data);
    ndcoord<Dim, int> shape(mat.size.p, mat.size.p + Dim);
    ndcoord<Dim, std::size_t> strides(mat.step.p, mat.step.p + Dim);
    return ndarray_view<Dim, T>(start, shape, strides);
}


}

#endif