Color.h

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
 
#include <SimoxUtility/color/Color.h>
 
#include <RobotAPI/interface/ArViz/Elements.h>
 
namespace armarx::viz
{
 
    struct Color : data::Color
    {
        using data::Color::Color;
 
        Color(const data::Color& c) : data::Color(c)
        {
        }
 
        Color(simox::Color c)
        {
            this->r = c.r;
            this->g = c.g;
            this->b = c.b;
            this->a = c.a;
        }
 
        Color(int r, int g, int b, int a = 255)
        {
            this->r = simox::color::to_byte(r);
            this->g = simox::color::to_byte(g);
            this->b = simox::color::to_byte(b);
            this->a = simox::color::to_byte(a);
        }
 
        Color(float r, float g, float b, float a = 1.0)
        {
            this->r = simox::color::to_byte(r);
            this->g = simox::color::to_byte(g);
            this->b = simox::color::to_byte(b);
            this->a = simox::color::to_byte(a);
        }
 
        /// Construct a byte color from R, G, B and optional alpha.
        static inline Color
        fromRGBA(int r, int g, int b, int a = 255)
        {
            return {r, g, b, a};
        }
 
        /// Construct a float color from R, G, B and optional alpha.
        static inline Color
        fromRGBA(float r, float g, float b, float a = 1.0)
        {
            return {r, g, b, a};
        }
 
        /// Construct from a simox Color.
        static inline Color
        fromRGBA(simox::Color c)
        {
            return {c};
        }
 
        // Colorless
 
        static inline Color
        black(int a = 255)
        {
            return simox::Color::black(a);
        }
 
        static inline Color
        white(int a = 255)
        {
            return simox::Color::white(a);
        }
 
        static inline Color
        gray(int g = 128, int a = 255)
        {
            return simox::Color::gray(g, a);
        }
 
        // Primary colors
 
        static inline Color
        red(int r = 255, int a = 255)
        {
            return simox::Color::red(r, a);
        }
 
        static inline Color
        green(int g = 255, int a = 255)
        {
            return simox::Color::green(g, a);
        }
 
        static inline Color
        blue(int b = 255, int a = 255)
        {
            return simox::Color::blue(b, a);
        }
 
        // Secondary colors
 
        /// Green + Blue
        static inline Color
        cyan(int c = 255, int a = 255)
        {
            return simox::Color::cyan(c, a);
        }
 
        /// Red + Green
        static inline Color
        yellow(int y = 255, int a = 255)
        {
            return simox::Color::yellow(y, a);
        }
 
        /// Red + Blue
        static inline Color
        magenta(int m = 255, int a = 255)
        {
            return simox::Color::magenta(m, a);
        }
 
        // 2:1 Mixed colors
 
        /// 2 Red + 1 Green
        static inline Color
        orange(int o = 255, int a = 255)
        {
            return simox::Color::orange(o, a);
        }
 
        /// 2 Red + 1 Blue
        static inline Color
        pink(int p = 255, int a = 255)
        {
            return simox::Color::pink(p, a);
        }
 
        /// 2 Green + 1 Red
        static inline Color
        lime(int l = 255, int a = 255)
        {
            return simox::Color::lime(l, a);
        }
 
        /// 2 Green + 1 Blue
        static inline Color
        turquoise(int t = 255, int a = 255)
        {
            return simox::Color::turquoise(t, a);
        }
 
        /// 2 Blue + 1 Green
        static inline Color
        azure(int az = 255, int a = 255)
        {
            return simox::Color::azure(az, a);
        }
 
        /// 2 Blue + 1 Red
        static inline Color
        purple(int p = 255, int a = 255)
        {
            return simox::Color::purple(p, a);
        }
    };
 
    inline std::ostream&
    operator<<(std::ostream& os, const Color& c)
    {
        return os << "(" << int(c.r) << " " << int(c.g) << " " << int(c.b) << " | " << int(c.a)
                  << ")";
    }
 
    inline bool
    operator==(const Color& lhs, const Color& rhs)
    {
        return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
    }
 
    inline bool
    operator!=(const Color& lhs, const Color& rhs)
    {
        return !(lhs == rhs);
    }
 
    namespace data
    {
        // viz::Color == simox::Color
        inline bool
        operator==(const viz::data::Color& lhs, const simox::color::Color& rhs)
        {
            return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
        }
 
        // simox::Color == viz::Color
        inline bool
        operator==(const simox::color::Color& lhs, const armarx::viz::data::Color& rhs)
        {
            return rhs == lhs;
        }
 
        inline std::ostream&
        operator<<(std::ostream& os, const viz::data::Color& c)
        {
            return os << "(" << int(c.r) << " " << int(c.g) << " " << int(c.b) << " | " << int(c.a)
                      << ")";
        }
    } // namespace data
} // namespace armarx::viz