MxArray.hpp

Go to the documentation of this file.

#ifndef __MXARRAY_HPP__
#define __MXARRAY_HPP__

#include <functional>
#include <map>
#include <stdint.h>
#include <string>
#include "mex.h"
#include "opencv2/opencv.hpp"

template <typename T>
struct MxTypes {
    static const mxClassID type = mxUNKNOWN_CLASS;
};

template<> struct MxTypes<int8_t> {
    static const mxClassID type = mxINT8_CLASS;
};

template<> struct MxTypes<uint8_t> {
    static const mxClassID type = mxUINT8_CLASS;
};

template<> struct MxTypes<int16_t> {
    static const mxClassID type = mxINT16_CLASS;
};

template<> struct MxTypes<uint16_t> {
    static const mxClassID type = mxUINT16_CLASS;
};

template<> struct MxTypes<int32_t> {
    static const mxClassID type = mxINT32_CLASS;
};

template<> struct MxTypes<uint32_t> {
    static const mxClassID type = mxUINT32_CLASS;
};

template<> struct MxTypes<int64_t> {
    static const mxClassID type = mxINT64_CLASS;
};

template<> struct MxTypes<uint64_t> {
    static const mxClassID type = mxUINT64_CLASS;
};

template<> struct MxTypes<float> {
    static const mxClassID type = mxSINGLE_CLASS;
};

template<> struct MxTypes<double> {
    static const mxClassID type = mxDOUBLE_CLASS;
};

template<> struct MxTypes<char> {
    static const mxClassID type = mxCHAR_CLASS;
};

template<> struct MxTypes<bool> {
    static const mxClassID type = mxLOGICAL_CLASS;
};

int MexErrorHandler(int status, const char *func_name, const char *err_msg,
    const char *file_name, int line, void *userdata);

class MxArray
{
  public:
    MxArray(const mxArray *arr) : p_(arr) {}
    MxArray(const MxArray& arr) : p_(arr.p_) {}
    MxArray& operator=(const MxArray& rhs);
    explicit MxArray(const int i);
    explicit MxArray(const double d);
    explicit MxArray(const bool b);
    explicit MxArray(const std::string& s);
    explicit MxArray(const cv::Mat& mat,
        mxClassID classid = mxUNKNOWN_CLASS, bool transpose = true);
    explicit MxArray(const cv::SparseMat& mat);
    explicit MxArray(const cv::Moments& m);
    explicit MxArray(const cv::KeyPoint& p);
    explicit MxArray(const cv::DMatch& m);
    explicit MxArray(const cv::RotatedRect& r);
    explicit MxArray(const cv::TermCriteria& t);
    template <typename T> explicit MxArray(const std::vector<T>& v)
    {
        // we do this: fromVector(v) as opposed to: fromVector<T>(v),
        // that way the call gets resolved to overloaded or
        // template-specialized version appropriately.
        // (although we dont currently have an overloaded version)
        fromVector(v);
    }
    template <typename T> explicit MxArray(const cv::Point_<T>& p);
    template <typename T> explicit MxArray(const cv::Point3_<T>& p);
    template <typename T> explicit MxArray(const cv::Size_<T>& s);
    template <typename T> explicit MxArray(const cv::Rect_<T>& r);
    template <typename T> explicit MxArray(const cv::Scalar_<T>& s);
    template <typename T, int cn> explicit MxArray(const cv::Vec<T,cn>& vec);
    template <typename T, int m, int n> explicit MxArray(const cv::Matx<T,m,n>& mat);
    virtual ~MxArray() {}
    static inline MxArray Cell(mwSize m = 1, mwSize n = 1)
    {
        mxArray *pm = mxCreateCellMatrix(m,n);
        if (!pm)
            mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
        return MxArray(pm);
    }
    static inline MxArray Struct(const char** fields = NULL,
        int nfields = 0, mwSize m = 1, mwSize n = 1)
    {
        mxArray *pm = mxCreateStructMatrix(m, n, nfields, fields);
        if (!pm)
            mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
        return MxArray(pm);
    }
    MxArray clone() const;
    void destroy() { mxDestroyArray(const_cast<mxArray*>(p_)); }
    operator const mxArray*() const { return p_; };
    operator mxArray*() const { return const_cast<mxArray*>(p_); };
    int toInt() const;
    double toDouble() const;
    float toFloat() const;
    bool toBool() const;
    std::string toString() const;
    cv::Mat toMat(int depth = CV_USRTYPE1, bool transpose = true) const;
    cv::MatND toMatND(int depth = CV_USRTYPE1, bool transpose = true) const;
    cv::SparseMat toSparseMat(int depth = CV_USRTYPE1) const;
    cv::Moments toMoments(mwIndex index = 0) const;
    cv::KeyPoint toKeyPoint(mwIndex index = 0) const;
    cv::DMatch toDMatch(mwIndex index = 0) const;
    cv::Range toRange() const;
    cv::RotatedRect toRotatedRect(mwIndex index = 0) const;
    cv::TermCriteria toTermCriteria(mwIndex index = 0) const;
    template <typename T> cv::Point_<T> toPoint_() const;
    template <typename T> cv::Point3_<T> toPoint3_() const;
    template <typename T> cv::Size_<T> toSize_() const;
    template <typename T> cv::Rect_<T> toRect_() const;
    template <typename T> cv::Scalar_<T> toScalar_() const;
    template <typename T, int cn> cv::Vec<T,cn> toVec() const;
    template <typename T, int m, int n> cv::Matx<T,m,n> toMatx() const;
    template <typename T> std::vector<T> toVector() const;
    template <typename T>
    std::vector<T> toVector(std::const_mem_fun_ref_t<T, MxArray> f) const;
    inline cv::Point toPoint() const { return toPoint_<int>(); }
    inline cv::Point2f toPoint2f() const { return toPoint_<float>(); }
    inline cv::Point3f toPoint3f() const { return toPoint3_<float>(); }
    inline cv::Size toSize() const { return toSize_<int>(); }
    inline cv::Rect toRect() const { return toRect_<int>(); }
    inline cv::Scalar toScalar() const { return toScalar_<double>(); }
    inline mxClassID classID() const { return mxGetClassID(p_); }
    inline const std::string className() const
    {
        return std::string(mxGetClassName(p_));
    }
    inline mwSize numel() const { return mxGetNumberOfElements(p_); }
    inline mwSize ndims() const { return mxGetNumberOfDimensions(p_); }
    inline const mwSize* dims() const { return mxGetDimensions(p_); }
    inline mwSize rows() const { return mxGetM(p_); }
    inline mwSize cols() const { return mxGetN(p_); }
    inline int nfields() const { return mxGetNumberOfFields(p_); }
    std::string fieldname(int fieldnumber) const;
    std::vector<std::string> fieldnames() const;
    inline mwSize nzmax() const { return mxGetNzmax(p_); }
    mwIndex subs(mwIndex i, mwIndex j = 0) const;
    mwIndex subs(const std::vector<mwIndex>& si) const;
    inline bool isNull() const { return (p_ == NULL); }
    inline bool isCell() const { return mxIsCell(p_); }
    inline bool isChar() const { return mxIsChar(p_); }
    inline bool isClass(std::string s) const
    {
        return mxIsClass(p_, s.c_str());
    }
    inline bool isComplex() const { return mxIsComplex(p_); }
    inline bool isDouble() const { return mxIsDouble(p_); }
    inline bool isEmpty() const { return mxIsEmpty(p_); }
    static inline bool isFinite(double d) { return mxIsFinite(d); }
    inline bool isFromGlobalWS() const { return mxIsFromGlobalWS(p_); }
    static inline bool isInf(double d) { return mxIsInf(d); }
    inline bool isInt8() const { return mxIsInt8(p_); }
    inline bool isInt16() const { return mxIsInt16(p_); }
    inline bool isInt32() const { return mxIsInt32(p_); }
    inline bool isInt64() const { return mxIsInt64(p_); }
    inline bool isLogical() const { return mxIsLogical(p_); }
    inline bool isLogicalScalar() const { return mxIsLogicalScalar(p_); }
    inline bool isLogicalScalarTrue() const
    {
        return mxIsLogicalScalarTrue(p_);
    }
    inline bool isNumeric() const { return mxIsNumeric(p_); }
    inline bool isSingle() const { return mxIsSingle(p_); }
    inline bool isSparse() const { return mxIsSparse(p_); }
    inline bool isStruct() const { return mxIsStruct(p_); }
    inline bool isUint8() const { return mxIsUint8(p_); }
    inline bool isUint16() const { return mxIsUint16(p_); }
    inline bool isUint32() const { return mxIsUint32(p_); }
    inline bool isUint64() const { return mxIsUint64(p_); }
    inline bool isInteger() const
    {
        return (isUint8() || isInt8() || isUint16() || isInt16() ||
            isUint32() || isInt32() || isUint64() || isInt64());
    }
    inline bool isFloat() const { return (isDouble() || isSingle()); }
    inline bool isField(const std::string& fieldName) const
    {
        return isStruct() && mxGetFieldNumber(p_, fieldName.c_str()) != -1;
    }
    template <typename T> T at(mwIndex index) const;
    template <typename T> T at(mwIndex i, mwIndex j) const;
    template <typename T> T at(const std::vector<mwIndex>& si) const;
    MxArray at(const std::string& fieldName, mwIndex index = 0) const;
    template <typename T> void set(mwIndex index, const T& value);
    template <typename T> void set(mwIndex i, mwIndex j, const T& value);
    template <typename T> void set(const std::vector<mwIndex>& si,
        const T& value);
    template <typename T> void set(const std::string& fieldName,
        const T& value, mwIndex index = 0);
    static inline bool isNaN(double d) { return mxIsNaN(d); }
    static inline double Inf() { return mxGetInf(); }
    static inline double NaN() { return mxGetNaN(); }
    static inline double Eps() { return mxGetEps(); }

  private:
    template <typename T> void fromVector(const std::vector<T>& v);
    const mxArray* p_;
};

template <typename T, typename U>
class ConstMap
{
  public:
    ConstMap(const T& key, const U& val)
    {
        m_[key] = val;
    }
    ConstMap<T,U>& operator() (const T& key, const U& val)
    {
        m_[key] = val;
        return *this;
    }
    operator std::map<T,U>() const { return m_; }
    const U& operator[] (const T& key) const
    {
        typename std::map<T,U>::const_iterator it = m_.find(key);
        if (it==m_.end())
            mexErrMsgIdAndTxt("mexopencv:error", "ConstMap: Value not found");
        return (*it).second;
    }
  private:
    std::map<T,U> m_;
};

template <typename T>
void MxArray::fromVector(const std::vector<T>& v)
{
    if (MxTypes<T>::type == mxUNKNOWN_CLASS) {
        p_ = mxCreateCellMatrix(1, v.size());
        if (!p_)
            mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
        for (mwIndex i = 0; i < v.size(); ++i)
            mxSetCell(const_cast<mxArray*>(p_), i, MxArray(v[i]));
    } else {
        p_ = mxCreateNumericMatrix(1, v.size(), MxTypes<T>::type, mxREAL);
        if (!p_)
            mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
        std::copy(v.begin(), v.end(), reinterpret_cast<T*>(mxGetData(p_)));
    }
}

template <typename T>
MxArray::MxArray(const cv::Point_<T>& p)
    : p_(mxCreateNumericMatrix(1, 2, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    double *x = mxGetPr(p_);
    x[0] = static_cast<double>(p.x);
    x[1] = static_cast<double>(p.y);
}

template <typename T>
MxArray::MxArray(const cv::Point3_<T>& p)
    : p_(mxCreateNumericMatrix(1, 3, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    double *x = mxGetPr(p_);
    x[0] = static_cast<double>(p.x);
    x[1] = static_cast<double>(p.y);
    x[2] = static_cast<double>(p.z);
}

template <typename T>
MxArray::MxArray(const cv::Size_<T>& s)
    : p_(mxCreateNumericMatrix(1, 2, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    double *x = mxGetPr(p_);
    x[0] = static_cast<double>(s.width);
    x[1] = static_cast<double>(s.height);
}

template <typename T>
MxArray::MxArray(const cv::Rect_<T>& r)
    : p_(mxCreateNumericMatrix(1, 4, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    double *x = mxGetPr(p_);
    x[0] = static_cast<double>(r.x);
    x[1] = static_cast<double>(r.y);
    x[2] = static_cast<double>(r.width);
    x[3] = static_cast<double>(r.height);
}

template <typename T>
MxArray::MxArray(const cv::Scalar_<T>& s)
    : p_(mxCreateNumericMatrix(1, 4, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    double *x = mxGetPr(p_);
    x[0] = static_cast<double>(s[0]);
    x[1] = static_cast<double>(s[1]);
    x[2] = static_cast<double>(s[2]);
    x[3] = static_cast<double>(s[3]);
}

template <typename T, int cn>
MxArray::MxArray(const cv::Vec<T,cn>& vec)
    : p_(mxCreateNumericMatrix(1, cn, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    /*
    double *x = mxGetPr(p_);
    for (mwIndex i=0; i<cn; i++)
        //set<double>(i, static_cast<double>(vec[i]));
        x[i] = static_cast<double>(vec[i]);
    */
    std::copy(vec.val, vec.val + cn, mxGetPr(p_));
}

template <typename T, int m, int n>
MxArray::MxArray(const cv::Matx<T,m,n>& mat)
    : p_(mxCreateNumericMatrix(m, n, mxDOUBLE_CLASS, mxREAL))
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Allocation error");
    /*
    double *x = mxGetPr(p_);
    for (mwIndex j=0; j<n; j++)
       for (mwIndex i=0; i<m; i++)
           //set<double>(i, j, static_cast<double>(mat(i,j)));
           x[j*m+i] = static_cast<double>(mat(i,j));
    */
    // Note: C is row-major, MATLAB uses column-major order
    const cv::Matx<T, n, m> mat_t = mat.t();
    std::copy(mat_t.val, mat_t.val + m*n, mxGetPr(p_));
}

template <typename T>
cv::Point_<T> MxArray::toPoint_() const
{
    if (!isNumeric() || numel() != 2)
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a cv::Point");
    return cv::Point_<T>(at<T>(0), at<T>(1));
}

template <typename T>
cv::Point3_<T> MxArray::toPoint3_() const
{
    if (!isNumeric() || numel() != 3)
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a cv::Point3");
    return cv::Point3_<T>(at<T>(0), at<T>(1), at<T>(2));
}

template <typename T>
cv::Size_<T> MxArray::toSize_() const
{
    if (!isNumeric() || numel() != 2)
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a cv::Size");
    return cv::Size_<T>(at<T>(0), at<T>(1));
}

template <typename T>
cv::Rect_<T> MxArray::toRect_() const
{
    if (!isNumeric() || numel() != 4)
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a cv::Rect");
    return cv::Rect_<T>(at<T>(0), at<T>(1), at<T>(2), at<T>(3));
}

template <typename T>
cv::Scalar_<T> MxArray::toScalar_() const
{
    const mwSize n = numel();
    if (!isNumeric() || n < 1 || 4 < n)
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a cv::Scalar");
    switch (n) {
        case 1: return cv::Scalar_<T>(at<T>(0));
        case 2: return cv::Scalar_<T>(at<T>(0), at<T>(1));
        case 3: return cv::Scalar_<T>(at<T>(0), at<T>(1), at<T>(2));
        case 4: return cv::Scalar_<T>(at<T>(0), at<T>(1), at<T>(2), at<T>(3));
        default: return cv::Scalar_<T>();
    }
}

template <typename T, int cn>
cv::Vec<T,cn> MxArray::toVec() const
{
    if (!isNumeric() || numel() != cn)
        mexErrMsgIdAndTxt("mexopencv:error",
            "MxArray is not a cv::Vec%d", cn);
    /*
    std::vector<T> v(toVector<T>());
    return (!v.empty() && v.size() == cn) ?
        cv::Vec<T,cn>(&v[0]) : cv::Vec<T,cn>();
    */
    cv::Vec<T,cn> vec;
    for (mwIndex i = 0; i < cn; i++)
        vec[i] = at<T>(i);
    return vec;
}

template <typename T, int m, int n>
cv::Matx<T,m,n> MxArray::toMatx() const
{
    if (!isNumeric() || numel() != m*n || rows() != m || cols() != n)
        mexErrMsgIdAndTxt("mexopencv:error",
            "MxArray is not a cv::Matx%d%d", m, n);
    /*
    // C is row-major, MATLAB is column-major order
    std::vector<T> v(toVector<T>());
    return (!v.empty() && v.size() == m*n) ?
        cv::Matx<T,n,m>(&v[0]).t() : cv::Matx<T,m,n>();
    */
    cv::Matx<T,m,n> mat;
    for (mwIndex j = 0; j<n; j++)
        for (mwIndex i = 0; i<m; i++)
            //mat(i,j) = at<T>(j*m+i);
            mat(i,j) = at<T>(i,j);
    return mat;
}

template <typename T>
std::vector<T> MxArray::toVector() const
{
    const mwSize n = numel();
    std::vector<T> vt;
    vt.reserve(n);
    if (isNumeric() || isLogical() || isChar()) {
        /*
        // shorter but slower implementation
        for (mwIndex i = 0; i < n; ++i)
            vt.push_back(at<T>(i));
        */
        switch (classID()) {
            case mxDOUBLE_CLASS: {
                const double *data = mxGetPr(p_);
                //std::copy(data, data + n, vt.begin());
                vt.assign(data, data + n);
                break;
            }
            case mxSINGLE_CLASS: {
                const float *data = reinterpret_cast<float*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxUINT8_CLASS: {
                const uint8_t *data = reinterpret_cast<uint8_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxINT8_CLASS: {
                const int8_t *data = reinterpret_cast<int8_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxUINT16_CLASS: {
                const uint16_t *data = reinterpret_cast<uint16_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxINT16_CLASS: {
                const int16_t *data = reinterpret_cast<int16_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxUINT32_CLASS: {
                const uint32_t *data = reinterpret_cast<uint32_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxINT32_CLASS: {
                const int32_t *data = reinterpret_cast<int32_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxUINT64_CLASS: {
                const uint64_t *data = reinterpret_cast<uint64_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxINT64_CLASS: {
                const int64_t *data = reinterpret_cast<int64_t*>(mxGetData(p_));
                vt.assign(data, data + n);
                break;
            }
            case mxCHAR_CLASS: {
                const mxChar *data = mxGetChars(p_);
                vt.assign(data, data + n);
                break;
            }
            case mxLOGICAL_CLASS: {
                const mxLogical *data = mxGetLogicals(p_);
                vt.assign(data, data + n);
                break;
            }
            default:
                break;    // should never reach this case
        }
    }
    else if (isCell()) {
        for (mwIndex i = 0; i < n; ++i)
            //vt.push_back(at<MxArray>(i).at<T>(0));
            vt.push_back(MxArray(mxGetCell(p_, i)).at<T>(0));
    }
    else
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a std::vector");
    return vt;
}

template <typename T>
std::vector<T> MxArray::toVector(std::const_mem_fun_ref_t<T,MxArray> f) const
{
    const std::vector<MxArray> v(toVector<MxArray>());
    std::vector<T> vt;
    vt.reserve(v.size());
    for (std::vector<MxArray>::const_iterator it=v.begin(); it!=v.end(); ++it)
        vt.push_back(f(*it));
    return vt;
}

template <typename T>
T MxArray::at(mwIndex index) const
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Null pointer error");
    if (!isNumeric() && !isLogical() && !isChar())
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not primitive");
    if (numel() <= index)
        mexErrMsgIdAndTxt("mexopencv:error", "Index out of range");
    switch (classID()) {
        case mxCHAR_CLASS:
            return static_cast<T>(*(mxGetChars(p_) + index));
        case mxDOUBLE_CLASS:
            return static_cast<T>(*(mxGetPr(p_) + index));
        case mxINT8_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<int8_t*>(mxGetData(p_)) + index));
        case mxUINT8_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<uint8_t*>(mxGetData(p_)) + index));
        case mxINT16_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<int16_t*>(mxGetData(p_)) + index));
        case mxUINT16_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<uint16_t*>(mxGetData(p_)) + index));
        case mxINT32_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<int32_t*>(mxGetData(p_)) + index));
        case mxUINT32_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<uint32_t*>(mxGetData(p_)) + index));
        case mxINT64_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<int64_t*>(mxGetData(p_)) + index));
        case mxUINT64_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<uint64_t*>(mxGetData(p_)) + index));
        case mxSINGLE_CLASS:
            return static_cast<T>(
                *(reinterpret_cast<float*>(mxGetData(p_)) + index));
        case mxLOGICAL_CLASS:
            return static_cast<T>(*(mxGetLogicals(p_) + index));
        default:
            return static_cast<T>(0);    // should never reach this case
    }
}

template <typename T>
T MxArray::at(mwIndex i, mwIndex j) const
{
    return at<T>(subs(i,j));
}

template <typename T>
T MxArray::at(const std::vector<mwIndex>& si) const
{
    return at<T>(subs(si));
}

template <typename T>
void MxArray::set(mwIndex index, const T& value)
{
    if (!p_)
        mexErrMsgIdAndTxt("mexopencv:error", "Null pointer error");
    if (!isNumeric() && !isLogical() && !isChar())
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not primitive");
    if (numel() <= index)
        mexErrMsgIdAndTxt("mexopencv:error", "Index out of range");
    switch (classID()) {
        case mxCHAR_CLASS:
            *(mxGetChars(p_) + index) = static_cast<mxChar>(value);
            break;
        case mxDOUBLE_CLASS:
            *(mxGetPr(p_) + index) = static_cast<double>(value);
            break;
        case mxINT8_CLASS:
            *(reinterpret_cast<int8_t*>(mxGetData(p_)) + index) =
                static_cast<int8_t>(value);
            break;
        case mxUINT8_CLASS:
            *(reinterpret_cast<uint8_t*>(mxGetData(p_)) + index) =
                static_cast<uint8_t>(value);
            break;
        case mxINT16_CLASS:
            *(reinterpret_cast<int16_t*>(mxGetData(p_)) + index) =
                static_cast<int16_t>(value);
            break;
        case mxUINT16_CLASS:
            *(reinterpret_cast<uint16_t*>(mxGetData(p_)) + index) =
                static_cast<uint16_t>(value);
            break;
        case mxINT32_CLASS:
            *(reinterpret_cast<int32_t*>(mxGetData(p_)) + index) =
                static_cast<int32_t>(value);
            break;
        case mxUINT32_CLASS:
            *(reinterpret_cast<uint32_t*>(mxGetData(p_)) + index) =
                static_cast<uint32_t>(value);
            break;
        case mxINT64_CLASS:
            *(reinterpret_cast<int64_t*>(mxGetData(p_)) + index) =
                static_cast<int64_t>(value);
            break;
        case mxUINT64_CLASS:
            *(reinterpret_cast<uint64_t*>(mxGetData(p_)) + index) =
                static_cast<uint64_t>(value);
            break;
        case mxSINGLE_CLASS:
            *(reinterpret_cast<float*>(mxGetData(p_)) + index) =
                static_cast<float>(value);
            break;
        case mxLOGICAL_CLASS:
            *(mxGetLogicals(p_) + index) = static_cast<mxLogical>(value);
            break;
        default:
            break;    // should never reach this case
    }
}

template <typename T>
void MxArray::set(mwIndex i, mwIndex j, const T& value)
{
    set<T>(subs(i,j), value);
}

template <typename T>
void MxArray::set(const std::vector<mwIndex>& si, const T& value)
{
    set<T>(subs(si), value);
}

template <typename T>
void MxArray::set(const std::string& fieldName, const T& value, mwIndex index)
{
    if (!isStruct())
        mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not struct");
    if (numel() <= index)
        mexErrMsgIdAndTxt("mexopencv:error", "Index out of range");
    if (!isField(fieldName)) {
        if (mxAddField(const_cast<mxArray*>(p_), fieldName.c_str()) < 0)
            mexErrMsgIdAndTxt("mexopencv:error",
                "Failed to create a field '%s'", fieldName.c_str());
    }
    mxSetField(const_cast<mxArray*>(p_), index, fieldName.c_str(),
        static_cast<mxArray*>(MxArray(value)));
}

template<>
void MxArray::fromVector(const std::vector<char>& v);

template<>
void MxArray::fromVector(const std::vector<bool>& v);

template <>
MxArray::MxArray(const std::vector<cv::DMatch>& v);

template <>
MxArray::MxArray(const std::vector<cv::KeyPoint>& v);

template <>
MxArray::MxArray(const std::vector<cv::RotatedRect>& v);

template <>
MxArray MxArray::at(mwIndex index) const;

template <>
void MxArray::set(mwIndex index, const MxArray& value);

template <>
std::vector<MxArray> MxArray::toVector() const;

template <>
std::vector<std::string> MxArray::toVector() const;

template <>
std::vector<cv::Mat> MxArray::toVector() const;

template <>
std::vector<cv::Point> MxArray::toVector() const;

template <>
std::vector<cv::Point2f> MxArray::toVector() const;

template <>
std::vector<cv::Point2d> MxArray::toVector() const;

template <>
std::vector<cv::Point3i> MxArray::toVector() const;

template <>
std::vector<cv::Point3f> MxArray::toVector() const;

template <>
std::vector<cv::Point3d> MxArray::toVector() const;

template <>
std::vector<cv::Size> MxArray::toVector() const;

template <>
std::vector<cv::Rect> MxArray::toVector() const;

template <>
std::vector<cv::Vec2i> MxArray::toVector() const;

template <>
std::vector<cv::Vec2f> MxArray::toVector() const;

template <>
std::vector<cv::Vec3i> MxArray::toVector() const;

template <>
std::vector<cv::Vec3f> MxArray::toVector() const;

template <>
std::vector<cv::Vec4i> MxArray::toVector() const;

template <>
std::vector<cv::Vec4f> MxArray::toVector() const;

template <>
std::vector<cv::RotatedRect> MxArray::toVector() const;

template <>
std::vector<cv::KeyPoint> MxArray::toVector() const;

template <>
std::vector<cv::DMatch> MxArray::toVector() const;

#endif // __MXARRAY_HPP__