RGBColor.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: RGBColor
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Color.h>
#include <NDEVR/Vector.h>
#include <NDEVR/ObjectInfo.h>
namespace NDEVR
{
    class HSBColor;
    class HSLColor;
    class ACIColor;
    class XYZColor;
    class LABColor;
    class String;
    class TranslatedString;
    static const fltp04 inverse_255 = 1.0f/255.0f;
    /**
    * @class RGBColor
    * @brief Represents a color in the RGB space with optional alpha transparency.
    *
    * Extends the Vector class to include specific methods for RGB manipulation,
    * providing flexibility for use in graphics and image processing applications.
    */
    class RGBColor : public Vector<4, uint01>, public Color
    {
    public:
        static const uint01 r_pos = 0;//The index of red in the RGBA color struct 
        static const uint01 g_pos = 1;//The index of green in the RGBA color struct
        static const uint01 b_pos = 2;//The index of blue in the RGBA color struct
        static const uint01 a_pos = 3;//The index of alpha in the RGBA color struct
 
    public: 
        constexpr RGBColor()
            : Vector<4, uint01>(0)
        {}
        explicit RGBColor(uint04 value)
            : Vector<4, uint01>(*reinterpret_cast<Vector<4, uint01>*>(&value))
        {}
        constexpr RGBColor(const sint04 r, const sint04 g, const sint04 b, const sint04 a = 255)
            : Vector<4, uint01>(
                  cast<uint01>(clip(r, 0, 255))
                , cast<uint01>(clip(g, 0, 255))
                , cast<uint01>(clip(b, 0, 255))
                , cast<uint01>(clip(a, 0, 255)))
        {}
        /**
         * @brief Constructor to initialize color using integer values for each channel.
         * @param r Red channel value (0-255).
         * @param g Green channel value (0-255).
         * @param b Blue channel value (0-255).
         * @param a Alpha channel value (0-255, default is 255).
         */
        constexpr RGBColor(const uint01 r, const uint01 g, const uint01 b, const uint01 a = 255)
            : Vector<4, uint01>(r, g, b, a)
        {}
        /**
         * @brief Constructor to initialize color using floating-point values for each channel.
         * @param r Red channel value (0.0f-1.0f).
         * @param g Green channel value (0.0f-1.0f).
         * @param b Blue channel value (0.0f-1.0f).
         * @param a Alpha channel value (0.0f-1.0f, default is 1.0f).
         */
        NDEVR_BASE_API RGBColor(const fltp04 r, const fltp04 g, const fltp04 b, const fltp04 a = 1.0f);
        NDEVR_BASE_API RGBColor(const fltp08 r, const fltp08 g, const fltp08 b, const fltp08 a = 1.0f);
        constexpr RGBColor(const RGBColor& color)
            : Vector<4, uint01>(color)
        {}
        
        template<class t_type>
        RGBColor(const Vector<1, t_type>& color)
            : Vector<4, uint01>(color[0], color[0], color[0], 255)
        {}
        template<class t_type>
        RGBColor(const Vector<2, t_type>& color)
            : Vector<4, uint01>(cast<uint01>(color[0]), cast<uint01>(color[0]), cast<uint01>(color[0]), cast<uint01>(color[1]))
        {}
        template<class t_type>
        RGBColor(const Vector<3, t_type>& color)
            : Vector<4, uint01>(color.template as<3, uint01>(), 255)
        {}
        template<class t_type>
        RGBColor(const Vector<4, t_type>& color)
            : Vector<4, uint01>(color.template as<4, uint01>())
        {}
 
        NDEVR_BASE_API explicit RGBColor(const Vector<4, fltp04>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<4, fltp08>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<3, fltp04>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<3, fltp08>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<2, fltp04>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<2, fltp08>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<1, fltp04>& color);
        NDEVR_BASE_API explicit RGBColor(const Vector<1, fltp08>& color);
 
        NDEVR_BASE_API explicit RGBColor(const ACIColor&);
        NDEVR_BASE_API explicit RGBColor(const HSBColor&);
        NDEVR_BASE_API explicit RGBColor(const HSLColor&);
        NDEVR_BASE_API explicit RGBColor(const XYZColor&);
        NDEVR_BASE_API explicit RGBColor(const LABColor&);
 
        RGBColor opaque() const
        {
            return RGBColor(m_values[r_pos], m_values[g_pos], m_values[b_pos]);
        }
 
        inline fltp04 getF(uint01 channel) const
        {
            return m_values[channel] * inverse_255;
        }
        inline void setF(uint01 channel, fltp04 value)
        {
            m_values[channel] = cast<uint01>(value * 255);
        }
        
        
        NDEVR_BASE_API Vector<3, fltp04> get3F() const;
        NDEVR_BASE_API Vector<4, fltp04> get4F() const;
        
        NDEVR_BASE_API uint04 convertToRGBA32BitColor() const;
        NDEVR_BASE_API uint04 convertToABGR32BitColor() const;
        NDEVR_BASE_API static RGBColor CreateRGBA32BitColor(uint04 color_32);
        NDEVR_BASE_API static RGBColor CreateARGB32BitColor(uint04 color_32);
 
        NDEVR_BASE_API uint04 convertTo24BitColor() const;
        NDEVR_BASE_API static RGBColor create24BitColor(uint04 color_24);
 
        NDEVR_BASE_API bool isLight() const;
        NDEVR_BASE_API RGBColor contrastingColor() const;
 
        /**
        * @brief Returns the luminance of the color.
        * @return Luminance as a floating-point value.
        */
        NDEVR_BASE_API fltp04 luminance() const;
 
        size_t operator()() const
        {
            return convertToRGBA32BitColor();
        }
        constexpr RGBColor& operator=(const RGBColor& color)
        {
            for(uint04 dim = 0; dim < 4; ++dim)
                m_values[dim] = color.m_values[dim];
            return *this;
        }
        
        NDEVR_BASE_API TranslatedString getName() const;
        NDEVR_BASE_API String getHexRGBA() const;
        NDEVR_BASE_API String getHexARGB() const;
        NDEVR_BASE_API String getHexRGB() const;
        NDEVR_BASE_API static RGBColor Average(const RGBColor& a, const RGBColor& b, fltp04 percent = 0.5f);
        NDEVR_BASE_API static RGBColor Average(const RGBColor& a, const RGBColor& b, const RGBColor& c);
        NDEVR_BASE_API static RGBColor AverageLAB(const RGBColor& a, const RGBColor& b, fltp04 percent = 0.5f);
    private: 
        /**
         * @brief Utility method to calculate hue adjustment.
         * @param h Hue component.
         * @param m1 Intermediate value 1.
         * @param m2 Intermediate value 2.
         * @return Adjusted hue value.
         */
        static fltp04 hue(fltp04 h, fltp04 m1, fltp04 m2);
 
    };
 
    template<>
    struct ObjectInfo<RGBColor, true, false>
    {
        static const bool Vector = true;
        static const uint01 Dimensions = 4;
        /** Useful for buffers. Determines whether the object needs to call an allocater. */
        static const bool Primitive = true;
        /** True if the object is a pointer. */
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = false;
        static const bool Integer = false;
        static const bool Number = false;
        static const bool Enum = false;
        static const bool String = false;
        static const bool Color = true;
        static const bool Buffer = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<uint01, false> VectorSub() { return ObjectInfo<uint01, false>(); }
    };
    static_assert(sizeof(RGBColor) == 4, "Bad Color size");
 
    template<> constexpr const RGBColor Constant<RGBColor>::Invalid = RGBColor(255, 255, 254, 0);
    template<> constexpr const RGBColor Constant<RGBColor>::Max = RGBColor(255, 255, 255, 255);
    template<> constexpr const RGBColor Constant<RGBColor>::Min = RGBColor(0, 0, 0, 0);
 
    template<class t_type>
    constexpr RGBColor& operator*=(RGBColor& color, const t_type& value)
    {
        if (IsInvalid(color))
            return color;
        for (uint01 dim = 0; dim < 3; ++dim)
            color[dim] = cast<uint01>(value * cast<t_type>(color[dim]));
        return color;
    }
    constexpr RGBColor operator*(const RGBColor& color, const fltp04& value)
    {
        if (IsInvalid(color))
            return color;
        RGBColor new_color;
        for (uint01 dim = 0; dim < 3; ++dim)
            new_color[dim] = cast<uint01>(value * cast<fltp04>(color[dim]));
        new_color[RGBColor::a_pos] = color[RGBColor::a_pos];
        return new_color;
    }
    constexpr RGBColor operator*(const fltp04& value, const RGBColor& color)
    {
        if (IsInvalid(color))
            return color;
        RGBColor new_color;
        for (uint01 dim = 0; dim < 3; ++dim)
            new_color[dim] = cast<uint01>(value * cast<fltp04>(color[dim]));
        new_color[RGBColor::a_pos] = color[RGBColor::a_pos];
        return new_color;
    }
    static_assert(sizeof(RGBColor) == 4, "Bad color size");
};