Image.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_SIG_IMAGE_H
#define YARP_SIG_IMAGE_H
 
#include <yarp/conf/system.h>
#include <yarp/os/NetUint16.h>
#include <yarp/os/Portable.h>
#include <yarp/os/Type.h>
#include <yarp/os/Vocab.h>
#include <yarp/sig/api.h>
#include <map>
 
namespace yarp {
    namespace sig {
        class Image;
        class FlexImage;
        template <class T> class ImageOf;
 
        inline size_t PAD_BYTES (size_t len, size_t pad) {
            const size_t rem = len % pad;
            return (rem != 0) ? (pad - rem) : rem;
        }
    }
}
 
// the image types partially reflect the IPL image types.
// There must be a pixel type for every ImageType entry.
enum YarpVocabPixelTypesEnum
{
    VOCAB_PIXEL_INVALID = 0,
    VOCAB_PIXEL_MONO = yarp::os::createVocab('m','o','n','o'),
    VOCAB_PIXEL_MONO16 = yarp::os::createVocab('m','o','1','6'),
    VOCAB_PIXEL_RGB = yarp::os::createVocab('r','g','b'),
    VOCAB_PIXEL_RGBA = yarp::os::createVocab('r','g','b','a'),
    VOCAB_PIXEL_BGRA = yarp::os::createVocab('b','g','r','a'),
    VOCAB_PIXEL_INT = yarp::os::createVocab('i','n','t'),
    VOCAB_PIXEL_HSV = yarp::os::createVocab('h','s','v'),
    VOCAB_PIXEL_BGR = yarp::os::createVocab('b','g','r'),
    VOCAB_PIXEL_MONO_SIGNED = yarp::os::createVocab('s','i','g','n'),
    VOCAB_PIXEL_RGB_SIGNED = yarp::os::createVocab('r','g','b','-'),
    VOCAB_PIXEL_RGB_INT = yarp::os::createVocab('r','g','b','i'),
    VOCAB_PIXEL_MONO_FLOAT = yarp::os::createVocab('d','e','c'),
    VOCAB_PIXEL_RGB_FLOAT = yarp::os::createVocab('r','g','b','.'),
    VOCAB_PIXEL_HSV_FLOAT = yarp::os::createVocab('h','s','v','.'),
    VOCAB_PIXEL_ENCODING_BAYER_GRBG8 = yarp::os::createVocab('g', 'r', 'b', 'g'),   //grbg8
    VOCAB_PIXEL_ENCODING_BAYER_GRBG16 = yarp::os::createVocab('g', 'r', '1', '6'),  //grbg16
    VOCAB_PIXEL_ENCODING_BAYER_BGGR8 = yarp::os::createVocab('b', 'g', 'g', 'r'),     //bggr8
    VOCAB_PIXEL_ENCODING_BAYER_BGGR16 = yarp::os::createVocab('b', 'g', '1', '6'),  //bggr16
    VOCAB_PIXEL_ENCODING_BAYER_GBRG8 = yarp::os::createVocab('g', 'b', 'r', 'g'),  //gbrg8
    VOCAB_PIXEL_ENCODING_BAYER_GBRG16 = yarp::os::createVocab('g', 'b', '1', '6'),  //gbrg16
    VOCAB_PIXEL_ENCODING_BAYER_RGGB8 = yarp::os::createVocab('r', 'g', 'g', 'b'),   //rggb8
    VOCAB_PIXEL_ENCODING_BAYER_RGGB16 = yarp::os::createVocab('r', 'g', '1', '6'),  //rggb16
    VOCAB_PIXEL_YUV_420 = yarp::os::createVocab('y','u','v','a'),
    VOCAB_PIXEL_YUV_444 = yarp::os::createVocab('y','u','v','b'),
    VOCAB_PIXEL_YUV_422 = yarp::os::createVocab('y','u','v','c'),
    VOCAB_PIXEL_YUV_411 = yarp::os::createVocab('y','u','v','d')
};
 
class YARP_sig_API yarp::sig::Image : public yarp::os::Portable {
 
public:
 
    Image();
 
    Image(const Image& alt);
 
    Image(Image&& other) noexcept;
 
    Image& operator=(const Image& alt);
 
    Image& operator=(Image &&other) noexcept;
 
    ~Image() override;
 
 
    bool copy(const Image& alt);
 
 
    bool copy(const Image& alt, size_t w, size_t h);
 
 
    inline size_t width() const { return imgWidth; }
 
    inline size_t height() const { return imgHeight; }
 
    virtual size_t getPixelSize() const;
 
    virtual int getPixelCode() const;
 
    inline size_t getRowSize() const { return imgRowSize; }
 
 
    inline size_t getQuantum() const { return imgQuantum; }
 
    inline size_t getPadding() const
    {
        const size_t ret=imgRowSize-imgWidth*imgPixelSize;
        return ret;
    }
 
    inline unsigned char *getRow(size_t r)
    {
        // should we check limits?
        return reinterpret_cast<unsigned char *>(data[r]);
    }
 
    inline const unsigned char *getRow(size_t r) const
    {
        // should we check limits?
        return reinterpret_cast<const unsigned char *>(data[r]);
    }
 
    inline unsigned char *getPixelAddress(size_t x, size_t y) const {
        return reinterpret_cast<unsigned char *>(data[y] + x*imgPixelSize);
    }
 
    inline bool isPixel(size_t x, size_t y) const {
        return (x<imgWidth && y<imgHeight);
    }
 
    void zero();
 
    void resize(size_t imgWidth, size_t imgHeight);
 
    void resize(const Image& alt) {
        resize(alt.width(),alt.height());
    }
 
    void setExternal(const void *data, size_t imgWidth, size_t imgHeight);
 
    unsigned char *getRawImage() const;
 
    size_t getRawImageSize() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.2.0
 
    YARP_DEPRECATED_MSG("Use yarp::cv::toCvMat instead")
    void *getIplImage();
 
    YARP_DEPRECATED_MSG("Use yarp::cv::toCvMat instead")
    const void *getIplImage() const;
 
    YARP_DEPRECATED_MSG("Use yarp::cv::fromCvMat instead")
    void wrapIplImage(void *iplImage);
#endif // YARP_NO_DEPRECATED
 
    //void wrapRawImage(void *buf, int imgWidth, int imgHeight);
 
 
    bool read(yarp::os::ConnectionReader& connection) override;
 
    bool write(yarp::os::ConnectionWriter& connection) const override;
 
    void setQuantum(size_t imgQuantum);
 
    bool topIsLowIndex() const {
        return topIsLow;
    }
 
    void setTopIsLowIndex(bool flag) {
        topIsLow = flag;
    }
 
 
    char **getRowArray() {
        return data;
    }
 
    yarp::os::Type getReadType() const override {
        return yarp::os::Type::byName("yarp/image");
    }
 
protected:
 
    void setPixelCode(int imgPixelCode);
 
    //pixelCode and pixelsSize should be linked together consistently.
    //since setPixelCode set also the corresponding pixelSize setPixelSize should not be used at all except for
    //setting an arbitrary pixelSize with no corresponding pixel code (in that case the pixelCode will be set to -pixelSize).
    void setPixelSize(size_t imgPixelSize);
 
 
private:
    YARP_SUPPRESS_DLL_INTERFACE_WARNING
    static const std::map<YarpVocabPixelTypesEnum, size_t> pixelCode2Size;
    size_t imgWidth, imgHeight, imgPixelSize, imgRowSize, imgQuantum;
    int imgPixelCode;
    bool topIsLow;
 
    char **data;
    void *implementation;
 
    void synchronize();
    void initialize();
 
    void copyPixels(const unsigned char *src, size_t id1,
                    unsigned char *dest, size_t id2, size_t w, size_t h,
                    size_t imageSize, size_t quantum1, size_t quantum2,
                    bool topIsLow1, bool topIsLow2);
};
 
 
class YARP_sig_API yarp::sig::FlexImage : public yarp::sig::Image {
public:
 
    void setPixelCode(int imgPixelCode) {
        Image::setPixelCode(imgPixelCode);
    }
 
 
    void setPixelSize(size_t imgPixelSize) {
        Image::setPixelSize(imgPixelSize);
    //pixelCode and pixelsSize should be linked together consistently.
    //since setPixelCode set also the corresponding pixelSize setPixelSize should not be used at all except for
    //setting an arbitrary pixelSize with no corresponding pixel code (in that case the pixelCode will be set to -pixelSize).
    }
 
    void setQuantum(size_t imgQuantum) {
        Image::setQuantum(imgQuantum);
    }
 
private:
};
 
 
 
 
#include <yarp/os/NetInt32.h>
 
namespace yarp {
    namespace sig {
 
        typedef unsigned char PixelMono;
 
        typedef yarp::os::NetUint16 PixelMono16;
 
        typedef yarp::os::NetInt32 PixelInt;
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelRgb
        {
            unsigned char r{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char g{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char b{0}; // NOLINT(misc-non-private-member-variables-in-classes)
 
            PixelRgb() = default;
            PixelRgb(unsigned char n_r,
                     unsigned char n_g,
                     unsigned char n_b) :
                    r(n_r),
                    g(n_g),
                    b(n_b)
            {
            }
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelRgba
        {
            PixelRgba() = default;
            PixelRgba(unsigned char n_r,
                      unsigned char n_g,
                      unsigned char n_b,
                      unsigned char n_a) :
                    r(n_r),
                    g(n_g),
                    b(n_b),
                    a(n_a)
            {
            }
 
            unsigned char r{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char g{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char b{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char a{0}; // NOLINT(misc-non-private-member-variables-in-classes)
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelBgra
        {
            unsigned char b{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char g{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char r{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char a{0}; // NOLINT(misc-non-private-member-variables-in-classes)
 
            PixelBgra() = default;
            PixelBgra(unsigned char n_r,
                      unsigned char n_g,
                      unsigned char n_b,
                      unsigned char n_a) :
                    b(n_b),
                    g(n_g),
                    r(n_r),
                    a(n_a)
            {
            }
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelBgr
        {
            unsigned char b{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char g{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            unsigned char r{0}; // NOLINT(misc-non-private-member-variables-in-classes)
 
            PixelBgr() = default;
            PixelBgr(unsigned char n_r, unsigned char n_g, unsigned char n_b) :
                    b(n_b),
                    g(n_g),
                    r(n_r)
            {
            }
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelHsv
        {
            unsigned char h{0};
            unsigned char s{0};
            unsigned char v{0};
        };
        YARP_END_PACK
 
        typedef char PixelMonoSigned;
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelRgbSigned
        {
            char r{0};
            char g{0};
            char b{0};
        };
        YARP_END_PACK
 
        typedef float PixelFloat;
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelRgbFloat
        {
            float r{0.0F}; // NOLINT(misc-non-private-member-variables-in-classes)
            float g{0.0F}; // NOLINT(misc-non-private-member-variables-in-classes)
            float b{0.0F}; // NOLINT(misc-non-private-member-variables-in-classes)
 
            PixelRgbFloat() = default;
            PixelRgbFloat(float n_r,
                          float n_g,
                          float n_b) :
                    r(n_r),
                    g(n_g),
                    b(n_b)
            {
            }
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct YARP_sig_API PixelRgbInt
        {
            yarp::os::NetInt32 r{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            yarp::os::NetInt32 g{0}; // NOLINT(misc-non-private-member-variables-in-classes)
            yarp::os::NetInt32 b{0}; // NOLINT(misc-non-private-member-variables-in-classes)
 
            PixelRgbInt() = default;
            PixelRgbInt(int n_r,
                        int n_g,
                        int n_b) :
                    r(n_r),
                    g(n_g),
                    b(n_b)
            {
            }
        };
        YARP_END_PACK
 
        YARP_BEGIN_PACK
        struct PixelHsvFloat
        {
            float h{0.0F};
            float s{0.0F};
            float v{0.0F};
        };
        YARP_END_PACK
    }
}
 
 
template <class T>
class yarp::sig::ImageOf : public Image
{
private:
    T nullPixel;
public:
    ImageOf() : Image(),
        nullPixel()
    {
        setPixelCode(getPixelCode());
    }
 
    size_t getPixelSize() const override {
        return sizeof(T);
    }
 
    int getPixelCode() const override;
 
    inline T& pixel(size_t x, size_t y) {
        return *(reinterpret_cast<T*>(getPixelAddress(x,y)));
    }
 
    inline T& pixel(size_t x, size_t y) const {
        return *(reinterpret_cast<T*>(getPixelAddress(x,y)));
    }
 
    inline const T& operator()(size_t x, size_t y) const {
        return pixel(x,y);
    }
 
    inline T& operator()(size_t x, size_t y) {
        return pixel(x,y);
    }
 
    inline T& safePixel(size_t x, size_t y) {
        if (!isPixel(x,y)) { return nullPixel; }
        return *(reinterpret_cast<T*>(getPixelAddress(x,y)));
    }
 
    inline const T& safePixel(size_t x, size_t y) const {
        if (!isPixel(x,y)) { return nullPixel; }
        return *(reinterpret_cast<T*>(getPixelAddress(x,y)));
    }
};
 
namespace yarp {
namespace sig {
 
template<>
inline int ImageOf<yarp::sig::PixelMono>::getPixelCode() const {
    return VOCAB_PIXEL_MONO;
}
 
template<>
inline int ImageOf<yarp::sig::PixelMono16>::getPixelCode() const {
    return VOCAB_PIXEL_MONO16;
}
 
template<>
inline int ImageOf<yarp::sig::PixelRgb>::getPixelCode() const {
    return VOCAB_PIXEL_RGB;
}
 
template<>
inline int ImageOf<yarp::sig::PixelRgba>::getPixelCode() const {
    return VOCAB_PIXEL_RGBA;
}
 
template<>
inline int ImageOf<yarp::sig::PixelHsv>::getPixelCode() const {
    return VOCAB_PIXEL_HSV;
}
 
template<>
inline int ImageOf<yarp::sig::PixelBgr>::getPixelCode() const {
    return VOCAB_PIXEL_BGR;
}
 
template<>
inline int ImageOf<yarp::sig::PixelBgra>::getPixelCode() const {
    return VOCAB_PIXEL_BGRA;
}
 
template<>
inline int ImageOf<yarp::sig::PixelMonoSigned>::getPixelCode() const {
    return VOCAB_PIXEL_MONO_SIGNED;
}
 
template<>
inline int ImageOf<yarp::sig::PixelRgbSigned>::getPixelCode() const {
    return VOCAB_PIXEL_RGB_SIGNED;
}
 
template<>
inline int ImageOf<yarp::sig::PixelFloat>::getPixelCode() const {
    return VOCAB_PIXEL_MONO_FLOAT;
}
 
template<>
inline int ImageOf<yarp::sig::PixelRgbFloat>::getPixelCode() const {
    return VOCAB_PIXEL_RGB_FLOAT;
}
 
template<>
inline int ImageOf<yarp::sig::PixelRgbInt>::getPixelCode() const {
    return VOCAB_PIXEL_RGB_INT;
}
 
template<>
inline int ImageOf<yarp::sig::PixelHsvFloat>::getPixelCode() const {
    return VOCAB_PIXEL_HSV_FLOAT;
}
 
template<>
inline int ImageOf<yarp::sig::PixelInt>::getPixelCode() const {
    return VOCAB_PIXEL_INT;
}
 
template<typename T>
inline int ImageOf<T>::getPixelCode() const {
    return -(static_cast<int>(sizeof(T)));
}
 
} // namespace sig
} // namespace yarp
 
#endif // YARP_SIG_IMAGE_H