Image.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#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::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;
}
} // namespace yarp::sig
 
// 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::createVocab32('m','o','n','o'),
    VOCAB_PIXEL_MONO16 = yarp::os::createVocab32('m','o','1','6'),
    VOCAB_PIXEL_RGB = yarp::os::createVocab32('r','g','b'),
    VOCAB_PIXEL_RGBA = yarp::os::createVocab32('r','g','b','a'),
    VOCAB_PIXEL_BGRA = yarp::os::createVocab32('b','g','r','a'),
    VOCAB_PIXEL_INT = yarp::os::createVocab32('i','n','t'),
    VOCAB_PIXEL_HSV = yarp::os::createVocab32('h','s','v'),
    VOCAB_PIXEL_BGR = yarp::os::createVocab32('b','g','r'),
    VOCAB_PIXEL_MONO_SIGNED = yarp::os::createVocab32('s','i','g','n'),
    VOCAB_PIXEL_RGB_SIGNED = yarp::os::createVocab32('r','g','b','-'),
    VOCAB_PIXEL_RGB_INT = yarp::os::createVocab32('r','g','b','i'),
    VOCAB_PIXEL_MONO_FLOAT = yarp::os::createVocab32('d','e','c'),
    VOCAB_PIXEL_RGB_FLOAT = yarp::os::createVocab32('r','g','b','.'),
    VOCAB_PIXEL_HSV_FLOAT = yarp::os::createVocab32('h','s','v','.'),
    VOCAB_PIXEL_ENCODING_BAYER_GRBG8 = yarp::os::createVocab32('g', 'r', 'b', 'g'),   //grbg8
    VOCAB_PIXEL_ENCODING_BAYER_GRBG16 = yarp::os::createVocab32('g', 'r', '1', '6'),  //grbg16
    VOCAB_PIXEL_ENCODING_BAYER_BGGR8 = yarp::os::createVocab32('b', 'g', 'g', 'r'),     //bggr8
    VOCAB_PIXEL_ENCODING_BAYER_BGGR16 = yarp::os::createVocab32('b', 'g', '1', '6'),  //bggr16
    VOCAB_PIXEL_ENCODING_BAYER_GBRG8 = yarp::os::createVocab32('g', 'b', 'r', 'g'),  //gbrg8
    VOCAB_PIXEL_ENCODING_BAYER_GBRG16 = yarp::os::createVocab32('g', 'b', '1', '6'),  //gbrg16
    VOCAB_PIXEL_ENCODING_BAYER_RGGB8 = yarp::os::createVocab32('r', 'g', 'g', 'b'),   //rggb8
    VOCAB_PIXEL_ENCODING_BAYER_RGGB16 = yarp::os::createVocab32('r', 'g', '1', '6'),  //rggb16
    VOCAB_PIXEL_YUV_420 = yarp::os::createVocab32('y','u','v','a'),
    VOCAB_PIXEL_YUV_444 = yarp::os::createVocab32('y','u','v','b'),
    VOCAB_PIXEL_YUV_422 = yarp::os::createVocab32('y','u','v','c'),
    VOCAB_PIXEL_YUV_411 = yarp::os::createVocab32('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;
 
    bool operator==(const Image& alt) const;
 
    ~Image() override;
 
 
    bool copy(const Image& alt);
 
 
    bool copy(const Image& alt, size_t w, size_t h);
 
 
    bool move(Image&& alt) noexcept;
 
 
    bool swap(Image& alt);
 
 
    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;
 
    bool read(yarp::os::ConnectionReader& connection) override;
 
    bool write(yarp::os::ConnectionWriter& connection) const override;
 
    void setQuantum(size_t imgQuantum);
 
    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;
 
    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);
};
 
 
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::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};
    unsigned char g {0};
    unsigned char b {0};
 
    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};
    unsigned char g{0};
    unsigned char b{0};
    unsigned char a{0};
};
YARP_END_PACK
 
YARP_BEGIN_PACK
struct YARP_sig_API PixelBgra
{
    unsigned char b{0};
    unsigned char g{0};
    unsigned char r{0};
    unsigned char a{0};
 
    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};
    unsigned char g{0};
    unsigned char r{0};
 
    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};
    float g{0.0F};
    float b{0.0F};
 
    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};
    yarp::os::NetInt32 g{0};
    yarp::os::NetInt32 b{0};
 
    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
} // namespace yarp::sig
 
 
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::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 yarp::sig
 
#endif // YARP_SIG_IMAGE_H