LayeredImage.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024-2024 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_LAYERED_IMAGE_H
#define YARP_LAYERED_IMAGE_H
 
#include <yarp/os/Portable.h>
#include <yarp/sig/Image.h>
#include <vector>
 
namespace yarp::sig {
class LayeredImage;
class ImageLayer;
} // namespace yarp::sig
 
class YARP_sig_API yarp::sig::ImageLayer
{
    public:
    yarp::sig::FlexImage layer;
    bool enable=true;
    class colorkey_s
    {
        public:
        int  value;
        bool enable;
 
        //default constructor
        colorkey_s() : enable(true), value(0) {}
 
        void setValueAsPixelRgb(yarp::sig::PixelRgb v)
        {
            value = *reinterpret_cast<int*>(&v);
        }
        yarp::sig::PixelRgb getValueAsPixelRgb()
        {
            return *reinterpret_cast<yarp::sig::PixelRgb*>(&value);
        }
    };
    colorkey_s colorkey;
 
    class alpha_s
    {
        public:
        bool enable;
        float value;
 
        // default constructor
        alpha_s() : enable(true), value(1.0) {}
    };
    alpha_s alpha;
 
    bool can_be_compressed = true;
    int offset_x=0;
    int offset_y=0;
 
    ImageLayer(const yarp::sig::FlexImage& img, bool ena = true, colorkey_s ckey = colorkey_s(), alpha_s alph = alpha_s(), bool compress = true, int off_x = 0, int off_y = 0)
    {
        layer = img;
        enable = ena;
        colorkey = ckey;
        alpha = alph;
        can_be_compressed = compress;
        offset_x = off_x;
        offset_y = off_y;
    }
};
 
class YARP_sig_API yarp::sig::LayeredImage : public yarp::os::Portable
{
public:
    //internal data
    yarp::sig::FlexImage background;
    std::vector<yarp::sig::ImageLayer> layers;
 
public:
    LayeredImage();
 
    LayeredImage(const LayeredImage& alt);
 
    LayeredImage(LayeredImage&& other) noexcept;
 
    LayeredImage& operator=(const LayeredImage& alt);
 
    LayeredImage& operator=(LayeredImage&& other) noexcept;
 
    bool operator==(const LayeredImage& alt) const;
 
    ~LayeredImage() override;
 
    yarp::sig::FlexImage convert_to_flexImage();
 
    operator yarp::sig::FlexImage();
 
    void clear();
 
    bool read(yarp::os::ConnectionReader& connection) override;
 
    bool write(yarp::os::ConnectionWriter& connection) const override;
 
    yarp::os::Type getReadType() const override {
        return yarp::os::Type::byName("yarp/layeredimage");
    }
};
 
#endif // YARP_LAYERED_IMAGE_H