ImageWrapper.h

Go to the documentation of this file.

/*
 * Copyright (C) by
 *   MetraLabs GmbH (MLAB), GERMANY
 *  and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Redistribution and modification of this code is strictly prohibited.
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_TOOLBOXES_PYTHON_IMAGEWRAPPER_H_
#define _MIRA_TOOLBOXES_PYTHON_IMAGEWRAPPER_H_

#define BOOST_HAS_NUMPY_API (BOOST_VERSION >= 106300)

#include <python/BoostPythonWrapper.h>

#if BOOST_HAS_NUMPY_API
#include <boost/python/numpy.hpp>
#else
#include <boost/python/numeric.hpp>
#endif

#include <image/Img.h>

#if BOOST_HAS_NUMPY_API
#else
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#endif

#include <numpy/ndarrayobject.h>


namespace mira {
namespace python {


#if BOOST_HAS_NUMPY_API

    static boost::python::numpy::dtype getNumpyDtype(int cvDtype) {
        namespace np = boost::python::numpy;
        switch (cvDtype) {
            case CV_8U:
                return np::dtype::get_builtin<uint8>();
            case CV_8S:
                return np::dtype::get_builtin<int8>();
            case CV_16U:
                return np::dtype::get_builtin<uint16>();
            case CV_16S:
                return np::dtype::get_builtin<int16>();
            case CV_32S:
                return np::dtype::get_builtin<int32>();
            case CV_32F:
                return np::dtype::get_builtin<float>();
            case CV_64F:
                return np::dtype::get_builtin<double>();
            default:
                return np::dtype::get_builtin<char>();
        }
    }

    static int getCvDtype(boost::python::numpy::dtype numpyDtype) {
        namespace np = boost::python::numpy;
        int cvDtype = -1;
        if (numpyDtype == np::dtype::get_builtin<uint8>()) {
            cvDtype = CV_8U;
        } else if (numpyDtype == np::dtype::get_builtin<int8>()) {
            cvDtype = CV_8S;
        } else if (numpyDtype == np::dtype::get_builtin<uint16>()) {
            cvDtype = CV_16U;
        } else if (numpyDtype == np::dtype::get_builtin<int16>()) {
            cvDtype = CV_16S;
        } else if (numpyDtype == np::dtype::get_builtin<int32>()) {
            cvDtype = CV_32S;
        } else if (numpyDtype == np::dtype::get_builtin<float>()) {
            cvDtype = CV_32F;
        } else if (numpyDtype == np::dtype::get_builtin<double>()) {
            cvDtype = CV_64F;
        } else {
            MIRA_THROW(XLogical, "Cannot map given dtype from NumPy to OpenCV");
        }
        return cvDtype;
    }

#else

    static int getNumpyDtype(int cvDtype)
    {
        int numpyDtype = -1;
        switch(cvDtype)
        {
            case CV_8U:
                numpyDtype = NPY_UBYTE;
                break;
            case CV_8S:
                numpyDtype = NPY_BYTE;
                break;
            case CV_16U:
                numpyDtype = NPY_USHORT;
                break;
            case CV_16S:
                numpyDtype = NPY_SHORT;
                break;
            case CV_32S:
                numpyDtype = NPY_INT;
                break;
            case CV_32F:
                numpyDtype = NPY_FLOAT;
                break;
            case CV_64F:
                numpyDtype = NPY_DOUBLE;
                break;
            default:
                MIRA_THROW(XLogical, "Cannot convert CV dtype to NumPy dtype!");
        }
        return numpyDtype;
    }

    static int getCvDtype(int numpyDtype)
    {
        int cvDtype = -1;
        switch(numpyDtype) {
            case NPY_UBYTE:
                cvDtype = CV_8U;
                break;
            case NPY_BYTE:
                cvDtype = CV_8S;
                break;
            case NPY_USHORT:
                cvDtype = CV_16U;
                break;
            case NPY_SHORT:
                cvDtype = CV_16S;
                break;
            case NPY_INT:
                cvDtype = CV_32S;
                break;
            case NPY_FLOAT:
                cvDtype = CV_32F;
                break;
            case NPY_DOUBLE:
                cvDtype = CV_64F;
                break;
            default:
                cvDtype = -1;
        }
        return cvDtype;
    }
#endif

#if BOOST_HAS_NUMPY_API

    static int getCVByteDepth(int cvDtype) {
        switch (cvDtype) {
            case CV_8U:
            case CV_8S:
                return 1;
            case CV_16U:
            case CV_16S:
                return 2;
            case CV_32S:
            case CV_32F:
                return 4;
            case CV_64F:
                return 8;
            default: MIRA_THROW(XLogical, "Cannot convert CV dtype to byte depth!");
        }
        return 0;
    }

#endif

    template<typename T>
    struct ImageAccessorBase {
    };

    template<typename TPixel, int TChannels>
    struct ImageAccessorBase<mira::Img<TPixel, TChannels> > {

        static boost::python::object getMat(const mira::Img<TPixel, TChannels> &image) {
            using namespace boost::python;

            if (image.isEmpty()) {
                return boost::python::object();
            }

            cv::Mat mat = image.getMat();
#if BOOST_HAS_NUMPY_API
            // generate array description
            int nBytes = getCVByteDepth(image.depth());
            numpy::dtype dtype = getNumpyDtype(image.depth());
            tuple shape = make_tuple(image.height(), image.width(), image.channels());
            tuple stride = make_tuple(image.width() * image.channels() * nBytes,
                                      image.channels() * nBytes, nBytes);
            if (mat.isContinuous()) {
                return numpy::from_data((TPixel *) mat.data, dtype,
                                        shape, stride, object());//.copy();
            } else {
                cv::Mat clone = mat.clone();
                return numpy::from_data((TPixel *) clone.data, dtype,
                                        shape, stride, object());//.copy();
            }
#else
            npy_intp size[3] = {image.height(), image.width(), image.channels()};
            // create PyObject
            PyObject *pyObj;
            if(mat.isContinuous()) {
                pyObj = PyArray_SimpleNewFromData(
                    3, &size[0], getNumpyDtype(image.depth()), (TPixel*)mat.data
                );
            }
            else {
                cv::Mat clone = mat.clone();
                pyObj = PyArray_SimpleNewFromData(
                    3, &size[0], getNumpyDtype(image.depth()), (TPixel*)clone.data
                );
            }
            handle<> handle(pyObj);
            return numeric::array(handle);
#endif
        }

#if BOOST_HAS_NUMPY_API

        static cv::Mat arrayToMat(const boost::python::numpy::ndarray &arr)
#else
        static cv::Mat arrayToMat(const boost::python::numeric::array& arr)
#endif
        {
            // This can probably also be moved to the old API branch
            PyObject * pyObj = arr.ptr();
            if (!PyArray_Check(pyObj)) MIRA_THROW(XRuntime, "Not an array object");

#if BOOST_HAS_NUMPY_API
            int ndims = arr.get_nd();
            assert(ndims >= 2);

            int size[2] = {(int) arr.get_shape()[0], (int) arr.get_shape()[1]};
            size_t step[2] = {(size_t) arr.get_strides()[0], (size_t) arr.get_strides()[1]};

            int type = getCvDtype(arr.get_dtype());
            // for multidim arrays create multichannel img with just 2 dims but 'special' type
            if (ndims > 2) {
                ndims = 2;
                type = CV_MAKETYPE(type, arr.get_shape()[2]);
            }

            void *data = (void *) arr.get_data();
#else
            // there is probably a better way but I did not find it
            PyArrayObject* arrayObj = reinterpret_cast<PyArrayObject*>(pyObj);

            int ndims = PyArray_NDIM(arrayObj);
            assert(ndims >= 2);

            int size[2];
            size[0] = PyArray_DIMS(arrayObj)[0];
            size[1] = PyArray_DIMS(arrayObj)[1];

            size_t step[2];
            step[0] = PyArray_STRIDES(arrayObj)[0];
            step[1] = PyArray_STRIDES(arrayObj)[1];

            int type = getCvDtype(PyArray_TYPE(arrayObj));
            // for multidim arrays create multichannel img with just 2 dims but 'special' type
            if (ndims > 2) {
                ndims = 2;
                type = CV_MAKETYPE(type, PyArray_DIMS(arrayObj)[2]);
            }

            void* data = PyArray_DATA(arrayObj);
#endif

            // need to clone(), otherwise we just wrap arr's memory
            return cv::Mat(ndims, size, type, data, step).clone();
        }
    };

    template<typename T>
    struct ImageAccessor {
    };

    // need to specialize differently for typed and untyped image
    // as the way to convert from cv::Mat is different
    template<typename TPixel, int TChannels>
    struct ImageAccessor<mira::Img<TPixel, TChannels> >
            : public ImageAccessorBase<mira::Img<TPixel, TChannels> > {
        typedef mira::Img<TPixel, TChannels> ImgType;

#if BOOST_HAS_NUMPY_API
        static void setMat(ImgType &image, const boost::python::numpy::ndarray &arr)
#else
        static void setMat(ImgType& image, const boost::python::numeric::array& arr)
#endif
        {
            image = ImgType::convertFrom(ImageAccessorBase<ImgType>::arrayToMat(arr));
        }
    };

    template<>
    struct ImageAccessor<mira::Img<void, 1> >
            : public ImageAccessorBase<mira::Img<void, 1> > {

        typedef mira::Img<void, 1> ImgType;

#if BOOST_HAS_NUMPY_API
        static void setMat(ImgType &image, const boost::python::numpy::ndarray &arr)
#else
        static void setMat(ImgType& image, const boost::python::numeric::array& arr)
#endif
        {
            image = Img<void, 1>(ImageAccessorBase<ImgType>::arrayToMat(arr));
        }
    };

}} // namespaces

#endif //_MIRA_TOOLBOXES_PYTHON_IMAGEWRAPPER_H_