color.hpp

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

#ifndef __SYNFIG_COLOR_COLOR_HPP
#define __SYNFIG_COLOR_COLOR_HPP

#include <cmath>
#include <cassert>
#include <stdint.h>

#include <synfig/gamma.h>
#include <synfig/string.h>
#include <synfig/angle.h>


#ifdef USE_HALF_TYPE
#include <OpenEXR/half.h>
#endif
#ifdef USING_PCH
#   include "pch.h"
#else
#ifdef HAVE_CONFIG_H
#   include <config.h>
#endif

#include <ETL/angle>
#include <cstdio>

#endif

namespace synfig {

Color&  Color::operator+=(const Color &rhs)
{
    r_+=rhs.r_;
    g_+=rhs.g_;
    b_+=rhs.b_;
    a_+=rhs.a_;
    return *this;
}

Color& Color::operator-=(const Color &rhs)
{
    r_-=rhs.r_;
    g_-=rhs.g_;
    b_-=rhs.b_;
    a_-=rhs.a_;
    return *this;
}

Color& Color::operator*=(const float &rhs)
{
    r_*=rhs;
    g_*=rhs;
    b_*=rhs;
    a_*=rhs;
    return *this;
}

Color& Color::operator/=(const float &rhs)
{
    const float temp(value_type(1)/rhs);
    r_*=temp;
    g_*=temp;
    b_*=temp;
    a_*=temp;
    return *this;
}

Color Color::operator+(const Color &rhs) const
{
    return Color(*this)+=rhs;
}

Color Color::operator-(const Color &rhs) const
{ return Color(*this)-=rhs; }

Color Color::operator*(const float &rhs)const
{ return Color(*this)*=rhs; }

Color Color::operator/(const float &rhs)const
{ return Color(*this)/=rhs; }

bool Color::operator==(const Color &rhs)const
{ return r_==rhs.r_ && g_==rhs.g_ && b_==rhs.b_ && a_==rhs.a_; }

bool Color::operator!=(const Color &rhs)const
{ return r_!=rhs.r_ || g_!=rhs.g_ || b_!=rhs.b_ || a_!=rhs.a_; }

Color Color::operator-()const
{ return Color(-r_,-g_,-b_,-a_); }

Color Color::operator~()const
{ return Color(1.0f-r_,1.0f-g_,1.0f-b_,a_); }

bool Color::is_valid()const
{ return !isnan(r_) && !isnan(g_) && !isnan(b_) && !isnan(a_); }

Color Color::premult_alpha() const
{
    return Color (r_*a_, g_*a_, b_*a_, a_);
}

Color Color::demult_alpha() const
{
    if(a_)
    {
        const value_type inva = 1/a_;
        return Color (r_*inva, g_*inva, b_*inva, a_);
    }else return alpha();
}

Color::Color() :a_(0), r_(0), g_(0), b_(0) { }
Color::Color(const value_type &f) :a_(f),r_(f), g_(f), b_(f) { }
Color::Color(int f) :a_(f),r_(f), g_(f), b_(f) { }

Color::Color(const value_type& R,
             const value_type& G,
             const value_type& B,
             const value_type& A):
    a_(A),
    r_(R),
    g_(G),
    b_(B) { }

Color::Color(const Color& c, const value_type& A):
    a_(A),
    r_(c.r_),
    g_(c.g_),
    b_(c.b_) { }

Color::Color(const Color& c):
    a_(c.a_),
    r_(c.r_),
    g_(c.g_),
    b_(c.b_) { }

#ifdef USE_HALF_TYPE
    friend class ColorAccumulator;
    Color(const ColorAccumulator& c);
#endif

    //Color(const Color &c) { memcpy((void*)this, (const void*)&c, sizeof(Color)); }

    /*const Color &operator=(const value_type &i)
    {
        r_ = g_ = b_ = a_ = i;
        return *this;
    }*/
    //Color& operator=(const Color &c) { memcpy((void*)this, (const void*)&c, sizeof(Color)); return *this; }


const String Color::get_hex()const
{
    return String(real2hex(r_) + real2hex(g_) + real2hex(b_));
}


float Color::get_y() const
{
    return
        (float)get_r()*EncodeYUV[0][0]+
        (float)get_g()*EncodeYUV[0][1]+
        (float)get_b()*EncodeYUV[0][2];
}


float Color::get_u() const
{
    return
        (float)get_r()*EncodeYUV[1][0]+
        (float)get_g()*EncodeYUV[1][1]+
        (float)get_b()*EncodeYUV[1][2];
}


float Color::get_v() const
{
    return
        (float)get_r()*EncodeYUV[2][0]+
        (float)get_g()*EncodeYUV[2][1]+
        (float)get_b()*EncodeYUV[2][2];
}


float Color::get_s() const
{
    const float u(get_u()), v(get_v());
    return sqrt(u*u+v*v);
}

Color& Color::set_yuv(const float &y, const float &u, const float &v)
{
    set_r(y*DecodeYUV[0][0]+u*DecodeYUV[0][1]+v*DecodeYUV[0][2]);
    set_g(y*DecodeYUV[1][0]+u*DecodeYUV[1][1]+v*DecodeYUV[1][2]);
    set_b(y*DecodeYUV[2][0]+u*DecodeYUV[2][1]+v*DecodeYUV[2][2]);
    return *this;
}

Color& Color::set_y(const float &y) { return set_yuv(y,get_u(),get_v()); }

Color& Color::set_u(const float &u) { return set_yuv(get_y(),u,get_v()); }

Color& Color::set_v(const float &v) { return set_yuv(get_y(),get_u(),v); }

Color& Color::set_uv(const float& u, const float& v) { return set_yuv(get_y(),u,v); }


Color& Color::set_s(const float &x)
{
    float u(get_u()), v(get_v());
    const float s(sqrt(u*u+v*v));
    if(s)
    {
        u=(u/s)*x;
        v=(v/s)*x;
        return set_uv(u,v);
    }
    return *this;
}

Color Color::YUV(const float& y, const float& u, const float& v, const value_type& a)
    { return Color().set_yuv(y,u,v).set_a(a); }


Angle Color::get_hue() const
    { return Angle::tan(get_u(),get_v()); }

Angle Color::get_uv_angle() const { return get_hue(); }


Color& Color::set_hue(const Angle& theta)
{
    const float s(get_s());
    const float
        u(s*(float)Angle::sin(theta).get()),
        v(s*(float)Angle::cos(theta).get());
    return set_uv(u,v);
}

Color& Color::set_uv_angle(const Angle& theta) { return set_hue(theta); }

Color& Color::rotate_uv(const Angle& theta)
{
    const float a(Angle::sin(theta).get()), b(Angle::cos(theta).get());
    const float u(get_u()), v(get_v());

    return set_uv(b*u-a*v,a*u+b*v);
}

Color& Color::set_yuv(const float& y, const float& s, const Angle& theta)
{
    return
        set_yuv(
            y,
            s*(float)Angle::sin(theta).get(),
            s*(float)Angle::cos(theta).get()
        );
}

Color Color::YUV(const float& y, const float& s, const Angle& theta, const value_type& a)
    { return Color().set_yuv(y,s,theta).set_a(a); }



/*protected:

    value_type& operator[](const int i)
    {
        assert(i>=0);
        assert(i<(signed)(sizeof(Color)/sizeof(value_type)));
        return (&r_)[i];
    }

    const value_type& operator[](const int i)const
    {
        assert(i>=0);
        assert(i<(signed)(sizeof(Color)/sizeof(value_type)));
        return (&r_)[i];
    }
*/

} // synfig namespace

#endif // __SYNFIG_COLOR_COLOR_HPP