color.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_COLOR_COLOR_H_
#define GENESIS_UTILS_COLOR_COLOR_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2023 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include <string>
#include <utility> // swap
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Color
// =================================================================================================
 
class Color
{
public:
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    Color()
        : r_( 0.0 ), g_( 0.0 ), b_( 0.0 ), a_( 1.0 )
    {}
 
    Color( double r, double g, double b )
        : Color( r, g, b, 1.0 )
    {}
 
    Color( double r, double g, double b, double a );
 
    ~Color() = default;
 
    Color(Color const&) = default;
    Color(Color&&)      = default;
 
    Color& operator= (Color const&) = default;
    Color& operator= (Color&&)      = default;
 
    void swap (Color& other)
    {
        using std::swap;
        swap(r_, other.r_);
        swap(g_, other.g_);
        swap(b_, other.b_);
        swap(a_, other.a_);
    }
 
    // -------------------------------------------------------------------------
    //     Factories
    // -------------------------------------------------------------------------
 
    static Color from_bytes( unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255 );
 
    static Color from_hex( std::string const& hex_color, std::string const& prefix = "#" );
 
    // -------------------------------------------------------------------------
    //     Accessors
    // -------------------------------------------------------------------------
 
    double r() const
    {
        return r_;
    }
 
    double g() const
    {
        return g_;
    }
 
    double b() const
    {
        return b_;
    }
 
    double a() const
    {
        return a_;
    }
 
    unsigned char r_byte() const
    {
        return to_byte_( r_ );
    }
 
    unsigned char g_byte() const
    {
        return to_byte_( g_ );
    }
 
    unsigned char b_byte() const
    {
        return to_byte_( b_ );
    }
 
    unsigned char a_byte() const
    {
        return to_byte_( a_ );
    }
 
    // -------------------------------------------------------------------------
    //     Modificators
    // -------------------------------------------------------------------------
 
    void r (double value);
 
    void g (double value);
 
    void b (double value);
 
    void a (double value);
 
    void r_byte (unsigned char value)
    {
        r_ = from_byte_( value );
    }
 
    void g_byte (unsigned char value)
    {
        g_ = from_byte_( value );
    }
 
    void b_byte (unsigned char value)
    {
        b_ = from_byte_( value );
    }
 
    void a_byte (unsigned char value)
    {
        a_ = from_byte_( value );
    }
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    static unsigned char to_byte_( double v );
    static double from_byte_( unsigned char v );
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    double r_;
    double g_;
    double b_;
    double a_;
 
};
 
// =================================================================================================
//     Basic Operators
// =================================================================================================
 
inline void swap (Color& lhs, Color& rhs)
{
    lhs.swap(rhs);
}
 
inline bool operator == (Color const& lhs, Color const& rhs)
{
    // We consider two colors equal if their byte representations are equal.
    // This should be good enough for all practical purposes.
    return (
        ( lhs.r_byte() == rhs.r_byte() ) &&
        ( lhs.g_byte() == rhs.g_byte() ) &&
        ( lhs.b_byte() == rhs.b_byte() ) &&
        ( lhs.a_byte() == rhs.a_byte() )
    );
}
 
inline bool operator != (Color const& lhs, Color const& rhs)
{
    return !(lhs == rhs);
}
 
} // namespace utils
} // namespace genesis
 
#endif // include guard