Img.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * 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_IMG_H_
#define _MIRA_IMG_H_

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <platform/Types.h>
#include <geometry/Polygon.h>
#include <geometry/Size.h>
#include <serialization/BinarySerializer.h>
#include <serialization/NoGenericReflect.h>
#include <serialization/IsNotMetaSerializable.h>

#include <image/ImgPixel.h>
#include <image/ImgIterator.h>

#if CV_MAJOR_VERSION >= 4
# define MIRA_USE_IPL_IMAGE 0
#endif
#ifndef MIRA_USE_IPL_IMAGE
# define MIRA_USE_IPL_IMAGE 0
#endif

namespace mira {


template<typename TImg>
class ImgBase {
public:
    struct ImgFormat
    {
        ImgFormat(int depth, const std::string& type, int channels)
            : depth(depth), type(type), channels(channels)
        {}

        void reflect(JSONSerializer& r) {
            r.member("Depth", depth, "The data type's depth (bits/channel)");
            r.member("Channels", channels, "The number of channels");
            r.member("Type", type, "The data type (signed/unsigned/float)");
        }

        int depth;
        std::string type;
        int channels;
    };

protected:
    ImgBase() {
    }

    ImgBase(const cv::Mat& data) :
        mData(data) {
    }

    ImgBase(int width, int height, int type) :
        mData(height, width, type) {
    }

#if MIRA_USE_IPL_IMAGE > 0

    ImgBase(const IplImage* img, bool copyData = false) {
        mData = cv::cvarrToMat(img, copyData);
    }
#endif

    ImgBase(const ImgBase& other) :
        mData(other.mData) {
    }

public:
    operator const cv::Mat&() const {
        return mData;
    }

    operator cv::Mat&() {
        return mData;
    }

#if ((CV_MAJOR_VERSION == 2 && CV_MINOR_VERSION >= 3) || CV_MAJOR_VERSION >= 3)
    operator const cv::_OutputArray() const {
        return mData;
    }

    operator cv::_OutputArray() {
        return mData;
    }

    operator cv::_InputArray() {
        return mData;
    }

    operator const cv::_InputArray() const {
        return mData;
    }
#endif

#if MIRA_USE_IPL_IMAGE > 0
    operator IplImage() {
        return (IplImage) mData;
    }

    operator const IplImage() const {
        return (IplImage) mData;
    }
#endif

public:

    ImgBase& operator=(const ImgBase& other) {
        mData = other;
        return *this;
    }

    void assignROI(const cv::Rect& roi, const ImgBase& other)
    {
        cv::Mat roiMat = this->mData(roi);

        if(roiMat.cols!=other.width()||roiMat.rows!=other.height())
            MIRA_THROW(XLogical, "Target roi and source image width and height must match");

        // make sure, that type, channels and depth match !
        assert(CV_MAT_TYPE(other.mData.flags)  == CV_MAT_TYPE(roiMat.flags)&&
               CV_MAT_CN(other.mData.flags)    == CV_MAT_CN(roiMat.flags)  &&
               CV_MAT_DEPTH(other.mData.flags) == CV_MAT_DEPTH(roiMat.flags));

        // copy roi data scanline by scanline
        std::size_t bpl = other.bytesPerLine();
        for(int y=0; y<roi.height; ++y)
            memcpy(roiMat.data+y*(size_t)roiMat.step, other.data(y),bpl);
    }

    void assignMask(const cv::Rect& roi, const ImgBase& other, const cv::Mat& mask)
    {
        cv::Mat roiMat = this->mData(roi);

        if(roiMat.cols!=other.width()||roiMat.rows!=other.height())
            MIRA_THROW(XLogical, "Target roi and source image width and height must match");

        if(mask.cols!=other.width()||mask.rows!=other.height())
            MIRA_THROW(XLogical, "Mask and image width and height must match");

        // make sure, that type, channels and depth match !
        assert(CV_MAT_TYPE(other.mData.flags)  == CV_MAT_TYPE(roiMat.flags)&&
               CV_MAT_CN(other.mData.flags)    == CV_MAT_CN(roiMat.flags)  &&
               CV_MAT_DEPTH(other.mData.flags) == CV_MAT_DEPTH(roiMat.flags));

        other.mData.copyTo(roiMat, mask);
    }

    void assignPolygon(const cv::Rect& roi, const ImgBase& other, const Polygon2i& poly)
    {
        if(poly.empty())
            MIRA_THROW(XLogical, "Need at least 1 polygon point");

        std::vector<cv::Point> v;
        foreach (const Point2i& p, poly)
            v.emplace_back(p.x(), p.y());

        cv::Mat mask(roi.height, roi.width, CV_8U);
        mask = cv::Scalar(0);
        const cv::Point* vv[1] = { v.data() };
        int n[1] = { int(v.size()) };
        cv::fillPoly(mask, vv, n, 1, cv::Scalar(1));

        assignMask(roi, other, mask);
    }

public:


    bool operator==(const cv::Mat& other) const {

        if (other.cols != mData.cols || other.rows != mData.rows)
            return false; // not even dimensions are equal

        if (CV_MAT_TYPE(other.flags)  != CV_MAT_TYPE(mData.flags)  ||
            CV_MAT_CN(other.flags)    != CV_MAT_CN(mData.flags)    ||
            CV_MAT_DEPTH(other.flags) != CV_MAT_DEPTH(mData.flags)) // also flags must match
            return false;

        // compare scanline by scanline, byte by byte
        for (int y = 0; y < other.rows; ++y) {
            const uint8* a = other.ptr(y);
            const uint8* b = mData.ptr(y);
            for (int x = 0; x < other.cols; ++x) {
                if (a[x] != b[x])
                    return false; // we found a difference
            }
        }

        // if we reach here, both were equal
        return true;
    }

    bool operator!=(const cv::Mat& other) const {
        return !ImgBase::operator==(other);
    }

public:
    const cv::Mat& getMat() const {
        return mData;
    }

    bool empty() const {
        return mData.empty();
    }

    int width() const {
        return mData.cols;
    }

    int height() const {
        return mData.rows;
    }

    std::size_t step() const {
        return (size_t)mData.step;
    }

    std::size_t bytesPerLine() const {
        return mData.elemSize() * mData.cols;
    }

    Size2i size() const {
        return Size2i(mData.size());
    }

    int depth() const {
        return mData.depth();
    }

    int channels() const {
        return mData.channels();
    }

    bool isEmpty() const {
        return mData.empty();
    }

    uint8* data() { return mData.data; }

    const uint8* data() const { return mData.data; }


    uint8* data(int y) { return mData.data + y*step(); }

    const uint8* data(int y) const { return mData.data + y*step(); }

    ImgFormat format() const {
        static const char types[8] = {'U', 'S', 'U', 'S', 'S', 'F', 'F', '?'};
        return ImgFormat(8*mData.elemSize1(),
                         std::string(types+CV_MAT_DEPTH(mData.flags), 1),
                         mData.channels());
    }

public:

    void resize(const Size2i& s) {
        if(s==size())
            return; // no need to resize
        // create new matrix with requested size but same type
        mData = cv::Mat(s.height(), s.width(), mData.type());
    }

    void resize(int width, int height) {
        resize(Size2i(width,height));
    }

public:

    void clear()
    {
        std::size_t bpl = bytesPerLine();
        for(int y=0; y<height(); ++y)
            memset(data(y), 0, bpl);
    }


public:
    TImg clone() const {
        return TImg(mData.clone());
    }

public:
    std::size_t total() const {
        return mData.rows * mData.cols;
    }

public:

    MIRA_NO_GENERIC_REFLECT_MEMBER(TImg)

    
    template<typename Derived>
    void reflect(BinarySerializer<Derived>& r) {
        r.version(2, this);

        // try to serialize with codec, if any
        if(r.codec(mData))
            return;

        r.member("Width", mData.cols, "The width of the image");
        r.member("Height", mData.rows, "The height of the image");
        int type = mData.type();
        r.member("Type", type, "The data type including number of channels");

        std::size_t bpl = bytesPerLine();

        // serialize the image data line by line
        const uchar* data = mData.data;
        for (int i = 0; i < mData.rows; ++i, data += mData.step)
            r.write(data, bpl);

    }

    template<typename Derived>
    void reflect(BinaryDeserializer<Derived>& r) {
        int cols, rows, type;

        if(r.version(2, this) > 1) {
            // try to deserialize with codec, if any
            if(r.codec(mData))
                return;
        }

        r.member("Width", cols, "The width of the image");
        r.member("Height", rows, "The height of the image");
        r.member("Type", type, "The data type including number of channels");

        // create the empty image
        mData.create(rows, cols, type);

        std::size_t bpl = bytesPerLine();

        // and deserialize the image line by line
        uchar* data = mData.data;
        for (int i = 0; i < mData.rows; ++i, data += mData.step)
            r.read(data, bpl);
    }

    void reflect(JSONSerializer& r) {
        Size2i size(mData.cols, mData.rows);
        r.member("Size", size, "The image size", REFLECT_CTRLFLAG_TEMP_TRACKING);

        ImgFormat f = format();
        r.member("Format", f, "The storage format", REFLECT_CTRLFLAG_TEMP_TRACKING);
    }

protected:
    cv::Mat mData;
};


template<typename TImg, typename TPixel>
class ImgTypedBase: public ImgBase<TImg> {
    typedef ImgBase<TImg> Base;

protected:
    friend class ImgBase<TImg> ;

    ImgTypedBase(const cv::Mat& data) :
        Base(data) {
    }

    ImgTypedBase() {
        this->mData.flags = (this->mData.flags & ~CV_MAT_TYPE_MASK) | cv::DataType<TPixel>::type;
    }

    ImgTypedBase(int width, int height) :
        Base(width, height, cv::DataType<TPixel>::type) {
    }

public:
    static TImg convertFrom(const cv::Mat& other, bool alwaysCopy = false) {
        int targetType = cv::DataType<TPixel>::type;

        // if channels and type equals and we don't want to copy - just return the image
        if (!alwaysCopy && (CV_MAKETYPE(other.type(), other.channels()) == targetType))
            return TImg(other);

        cv::Mat otherData = other;
        cv::Mat data(otherData.rows, otherData.cols, targetType);

        if (other.channels() != data.channels()) {
            // we need to convert the number of channels

            // create a temporary image that has the type of the other
            // image but the number of channels of our target type
            cv::Mat tmp(otherData.rows, otherData.cols,
                        CV_MAKETYPE(otherData.type(), data.channels()));

            // use MixChannels and build fromTo-mapping first
            std::vector<int> fromTo(data.channels() * 2);

            int srcChannel = 0;
            for (int k = 0; k < data.channels(); ++k, ++srcChannel) {
                fromTo[2 * k] = (srcChannel < otherData.channels() ? srcChannel : 0);
                fromTo[2 * k + 1] = k;
            }

            cv::mixChannels(&otherData, 1, &tmp, 1, fromTo.data(),
                            data.channels());

            otherData = tmp;
        }

#if ((CV_MAJOR_VERSION == 2 && CV_MINOR_VERSION >= 3) || CV_MAJOR_VERSION >= 3)
        otherData.convertTo(data, targetType);
#else
        // Since this:
        //otherData.convertTo(data, targetType);
        // is buggy in the OpenCV 2.0-2.1, we have to use the
        // C-interface:
        CvMat src = otherData;
        CvMat dest = data;
        cvConvertScale(&src, &dest);
#endif
        return TImg(data);
    }

public:
    TImg& operator=(const TPixel& p) {
        castToMat() = p;
        return *This();
    }

    TPixel* operator[](int y) {
        return this->castToMat()[y];
    }

    const TPixel* operator[](int y) const {
        return this->castToMat()[y];
    }

    TImg operator()(const cv::Rect& roi) {
        return TImg(this->mData(roi));
    }

    TImg operator()(const cv::Rect& roi) const {
        return TImg(this->mData(roi));
    }


    TPixel& operator()(int x, int y) {
        return this->castToMat()(y, x);
    }

    const TPixel& operator()(int x, int y) const {
        return this->castToMat()(y, x);
    }

    TPixel& operator()(const cv::Point& p) {
        return this->castToMat()(p);
    }

    const TPixel& operator()(const cv::Point& p) const {
        return this->castToMat()(p);
    }

public:

    typedef ImgIterator<TPixel> iterator;
    typedef ImgConstIterator<TPixel> const_iterator;

    iterator begin() {
        return iterator(&castToMat());
    }

    iterator end() {
        iterator it(&castToMat());
        it += this->total();
        return it;
    }

    const_iterator begin() const {
        return const_iterator(&castToMat());
    }

    const_iterator end() const {
        const_iterator it(&castToMat());
        it += this->total();
        return it;
    }

public:

    MIRA_NO_GENERIC_REFLECT_MEMBER(TImg)

    
    template<typename Derived>
    void reflect(BinarySerializer<Derived>& r) {
        MIRA_REFLECT_BASE(r, Base);
    }

    template<typename Derived>
    void reflect(BinaryDeserializer<Derived>& r) {
        MIRA_REFLECT_BASE(r, Base);
        // make sure that the type of the deserialized image matches
        // to our type, otherwise throw exception
        if (this->mData.type() != cv::DataType<TPixel>::type)
            MIRA_THROW(XIO, "The deserialized image type "
                "(depth: " << this->mData.depth() << ", channels: "
                    << this->mData.channels() << ") "
                "does not match the type of the Img class "
                "(depth: " << CV_MAT_DEPTH(cv::DataType<TPixel>::type)
                    << ", channels: " << CV_MAT_CN(cv::DataType<TPixel>::type)
                    << ")");
    }

    void reflect(JSONSerializer& r) {
        MIRA_REFLECT_BASE(r, Base);
    }

protected:

    TImg* This() {
        return static_cast<TImg*> (this);
    }

    const TImg* This() const {
        return static_cast<const TImg*> (this);
    }

    cv::Mat_<TPixel>& castToMat() {
        return static_cast<cv::Mat_<TPixel>&> (this->mData);
    }

    const cv::Mat_<TPixel>& castToMat() const {
        return static_cast<const cv::Mat_<TPixel>&> (this->mData);
    }

};


template<typename T = void, int TChannels = 1>
class Img: public ImgTypedBase<Img<T, TChannels> , ImgPixel<T, TChannels> > {
public:
    typedef ImgPixel<T, TChannels> Pixel;

protected:

    typedef Img<T, TChannels> Self;
    typedef ImgTypedBase<Self, Pixel> Base;

protected:

    friend class ImgBase<Self> ;
    friend class ImgTypedBase<Self, Pixel> ;

    // this must NOT be public, otherwise one could spoil our type safety
    Img(const cv::Mat& data) :
        Base(data) {
    }

public:

    enum { Channels = TChannels };

public:

    Img() {
    }

    Img(int width, int height) :
        Base(width, height) {
    }
    Img(const Size2i& size) :
        Base(size.width(), size.height()) {
    }

public:
    Self& operator=(const Pixel& p) {
        return Base::operator=(p);
    }
};


template<typename T>
class Img<T, 1> : public ImgTypedBase<Img<T, 1> , T> {
public:
    typedef T Pixel;

protected:

    typedef Img<T, 1> Self;
    typedef ImgTypedBase<Self, Pixel> Base;

protected:

    friend class ImgBase<Self> ;
    friend class ImgTypedBase<Self, Pixel> ;

    // this must not be public, otherwise one could spoil our type safety
    Img(const cv::Mat& data) :
        Base(data) {
    }

public:

    enum { Channels = 1 };

public:

    Img() {
    }
    Img(int width, int height) :
        Base(width, height) {
    }
    Img(const Size2i& size) :
        Base(size.width(), size.height()) {
    }

public:
    Self& operator=(const Pixel& p) {
        return Base::operator=(p);
    }
};


template<>
class Img<void, 1> : public ImgBase<Img<void, 1> > {
    typedef Img<void, 1> Self;
    typedef ImgBase<Self> Base;

protected:
    friend class ImgBase<Self> ;

public:

    Img() {
    }
    Img(int width, int height, int type, int channels) :
        Base(width, height, CV_MAKETYPE(type, channels)) {
    }
    Img(const Size2i& size, int type, int channels) :
        Base(size.width(), size.height(), CV_MAKETYPE(type, channels)) {
    }

    template<typename TImg>
    Img(const ImgBase<TImg>& other) :
        Base(other) {
    }

#if MIRA_USE_IPL_IMAGE > 0

    Img(const IplImage* img, bool copyData = false) :
        Base(img, copyData) {
    }
#endif

    Img(const cv::Mat& data) :
        Base(data) {
    }

    template<typename TImg>
    Self& operator=(const ImgBase<TImg>& other) {
        mData = other.getMat();
        return *this;
    }


    Img operator()(const cv::Rect& roi) {
        return Img(this->mData(roi));
    }

    Img operator()(const cv::Rect& roi) const {
        return Img(this->mData(roi));
    }

    template <typename TPixel, int TChannels>
    bool hasType() const
    {
        return cv::DataType<TPixel>::depth == this->depth() &&
                TChannels==this->channels();
    }

public:

    typedef UntypedImgIterator iterator;
    typedef UntypedImgConstIterator const_iterator;

    iterator begin() {
        return iterator(&this->mData);
    }

    iterator end() {
        iterator it(&this->mData);
        it.ptr = it.sliceEnd = (this->mData.data + this->mData.step*(this->mData.rows-1)) +
                this->mData.cols * this->mData.elemSize();
        return it;
    }

    const_iterator begin() const {
        return const_iterator(&this->mData);
    }

    const_iterator end() const {
        const_iterator it(&this->mData);
        it.ptr = it.sliceEnd = (this->mData.data + this->mData.step*(this->mData.rows-1)) +
                this->mData.cols * this->mData.elemSize();
        return it;
    }

};



template <typename TPixel, int TChannels>
Img<TPixel,TChannels> img_cast(Img<>& other)
{
    // if other has the same type here, return typed shallow copy
    if(other.hasType<TPixel,TChannels>())
        return Img<TPixel,TChannels>::convertFrom(other);

    // otherwise cannot cast
    MIRA_THROW(XBadCast, "Cannot cast this untyped image with of type " <<
              other.depth() << "," << other.channels() <<
              " to channel of type " << cv::DataType<TPixel>::depth <<
              "," << TChannels);
}


template <typename TPixel, int TChannels>
class IsNotMetaSerializable<Img<TPixel, TChannels>> : public std::true_type {};


typedef Img<uint8, 1> Img8U1;

typedef Img<uint8, 2> Img8U2;

typedef Img<uint8, 3> Img8U3;

typedef Img<uint8, 4> Img8U4;

typedef Img<uint16, 1> Img16U1;

typedef Img<uint16, 2> Img16U2;

typedef Img<uint16, 3> Img16U3;

typedef Img<uint16, 4> Img16U4;

typedef Img<int16, 1> Img16S1;

typedef Img<int16, 2> Img16S2;

typedef Img<int16, 3> Img16S3;

typedef Img<int16, 4> Img16S4;

typedef Img<float, 1> Img32F1;

typedef Img<float, 2> Img32F2;

typedef Img<float, 3> Img32F3;

typedef Img<float, 4> Img32F4;

typedef Img<double, 1> Img64F1;

typedef Img<double, 2> Img64F2;

typedef Img<double, 3> Img64F3;

typedef Img<double, 4> Img64F4;


}//end namespace

#endif /* _MIRA_IMG_H_ */