synfig-core/src/synfig/color.h

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file color.h
   3 **      \brief Color Class Implementation
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007, 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === S T A R T =========================================================== */
  25
  26 #ifndef __SYNFIG_COLOR_H
  27 #define __SYNFIG_COLOR_H
  28
  29 /* === H E A D E R S ======================================================= */
  30
  31
  32 #include <math.h>
  33 #include <cassert>
  34 #include "gamma.h"
  35 #include <synfig/string.h>
  36 # include "angle.h"
  37
  38 #ifdef USE_HALF_TYPE
  39 #include <OpenEXR/half.h>
  40 #endif
  41
  42 /* === M A C R O S ========================================================= */
  43
  44 #define use_colorspace_gamma()  App::use_colorspace_gamma
  45 #define colorspace_gamma()              (2.2f)
  46 #define gamma_in(x)                             ((x>=0) ? pow((float)x,1.0f/colorspace_gamma()) : -pow((float)-x,1.0f/colorspace_gamma()))
  47 #define gamma_out(x)                    ((x>=0) ? pow((float)x,     colorspace_gamma()) : -pow((float)-x,     colorspace_gamma()))
  48
  49 #ifdef WIN32
  50 #include <float.h>
  51 #ifndef isnan
  52 extern "C" { int _isnan(double x); }
  53 #define isnan _isnan
  54 #endif
  55 #endif
  56
  57 // For some reason isnan() isn't working on macosx any more.
  58 // This is a quick fix.
  59 #if defined(__APPLE__) && !defined(SYNFIG_ISNAN_FIX)
  60 #ifdef isnan
  61 #undef isnan
  62 #endif
  63 inline bool isnan(double x) { return x != x; }
  64 inline bool isnan(float x) { return x != x; }
  65 #define SYNFIG_ISNAN_FIX 1
  66 #endif
  67
  68 namespace synfig {
  69
  70 #ifdef USE_HALF_TYPE
  71 typedef half ColorReal;
  72 #else
  73 typedef float ColorReal;
  74 #endif
  75
  76 static const float EncodeYUV[3][3]=
  77 {
  78         { 0.299f, 0.587f, 0.114f },
  79         { -0.168736f, -0.331264f, 0.5f },
  80         { 0.5f, -0.418688f, -0.081312f }
  81 };
  82
  83 static const float DecodeYUV[3][3]=
  84 {
  85         { 1.0f, 0.0f, 1.402f },
  86         { 1.0f, -0.344136f, -0.714136f },
  87         { 1.0f, 1.772f, 0.0f }
  88 };
  89
  90 /* === T Y P E D E F S ===================================================== */
  91
  92 /* === C L A S S E S & S T R U C T S ======================================= */
  93
  94 #ifdef USE_HALF_TYPE
  95 class ColorAccumulator;
  96 #endif
  97
  98
  99
 100
 101 /*!     \class Color
 102 **      \todo Writeme
 103 **      Future optimizations: lookup table for sqrt()?
 104 */
 105 class Color
 106 {
 107 public:
 108         typedef ColorReal value_type;
 109
 110 private:
 111         value_type a_, r_, g_, b_;
 112
 113 public:
 114
 115         const String get_string(void)const;
 116
 117         Color &
 118         operator+=(const Color &rhs)
 119         {
 120                 r_+=rhs.r_;
 121                 g_+=rhs.g_;
 122                 b_+=rhs.b_;
 123                 a_+=rhs.a_;
 124                 return *this;
 125         }
 126
 127         Color &
 128         operator-=(const Color &rhs)
 129         {
 130                 r_-=rhs.r_;
 131                 g_-=rhs.g_;
 132                 b_-=rhs.b_;
 133                 a_-=rhs.a_;
 134                 return *this;
 135         }
 136
 137         Color &
 138         operator*=(const float &rhs)
 139         {
 140                 r_*=rhs;
 141                 g_*=rhs;
 142                 b_*=rhs;
 143                 a_*=rhs;
 144                 return *this;
 145         }
 146
 147         Color &
 148         operator/=(const float &rhs)
 149         {
 150                 const float temp(value_type(1)/rhs);
 151                 r_*=temp;
 152                 g_*=temp;
 153                 b_*=temp;
 154                 a_*=temp;
 155                 return *this;
 156         }
 157
 158         Color
 159         operator+(const Color &rhs)const
 160         { return Color(*this)+=rhs; }
 161
 162         Color
 163         operator-(const Color &rhs)const
 164         { return Color(*this)-=rhs; }
 165
 166         Color
 167         operator*(const float &rhs)const
 168         { return Color(*this)*=rhs; }
 169
 170         Color
 171         operator/(const float &rhs)const
 172         { return Color(*this)/=rhs; }
 173
 174         bool
 175         operator==(const Color &rhs)const
 176         { return r_==rhs.r_ && g_==rhs.g_ && b_==rhs.b_ && a_==rhs.a_; }
 177
 178         bool
 179         operator!=(const Color &rhs)const
 180         { return r_!=rhs.r_ || g_!=rhs.g_ || b_!=rhs.b_ || a_!=rhs.a_; }
 181
 182         Color
 183         operator-()const
 184         { return Color(-r_,-g_,-b_,-a_); }
 185
 186         //! Effectively 1.0-color
 187         Color
 188         operator~()const
 189         { return Color(1.0f-r_,1.0f-g_,1.0f-b_,a_); }
 190
 191         bool is_valid()const
 192         { return !isnan(r_) && !isnan(g_) && !isnan(b_) && !isnan(a_); }
 193
 194         Color premult_alpha() const
 195         {
 196                 return Color (r_*a_, g_*a_, b_*a_, a_);
 197         }
 198
 199         Color demult_alpha() const
 200         {
 201                 if(a_)
 202                 {
 203                         const value_type inva = 1/a_;
 204                         return Color (r_*inva, g_*inva, b_*inva, a_);
 205                 }else return alpha();
 206         }
 207
 208 public:
 209         // ETL/trunk/ETL/_gaussian.h does:
 210         //   SR1=SR2=SR3=typename T::value_type();
 211         // and expects that to give it initialized colors
 212         // Otherwise the 'gaussian' blur type is random.
 213         Color() :a_(0), r_(0), g_(0), b_(0) { }
 214         Color(const value_type &f) :a_(f),r_(f), g_(f), b_(f) { }
 215         Color(int f) :a_(f),r_(f), g_(f), b_(f) { }
 216
 217         /*!     \param R Red
 218         **      \param G Green
 219         **      \param B Blue
 220         **      \param A Opacity(alpha) */
 221         Color(const value_type& R, const value_type& G, const value_type& B, const value_type& A=1):
 222                 a_(A),
 223                 r_(R),
 224                 g_(G),
 225                 b_(B) { }
 226
 227         /*!     \param c Source for color components
 228         **      \param A Opacity(alpha) */
 229         Color(const Color& c, const value_type& A):
 230                 a_(A),
 231                 r_(c.r_),
 232                 g_(c.g_),
 233                 b_(c.b_) { }
 234
 235
 236         //!     Copy constructor
 237         Color(const Color& c):
 238                 a_(c.a_),
 239                 r_(c.r_),
 240                 g_(c.g_),
 241                 b_(c.b_) { }
 242
 243 #ifdef USE_HALF_TYPE
 244         friend class ColorAccumulator;
 245         //!     Convert constructor
 246         Color(const ColorAccumulator& c);
 247 #endif
 248
 249         //!     Copy constructor
 250         //Color(const Color &c) { memcpy((void*)this, (const void*)&c, sizeof(Color)); }
 251
 252         /*const Color &operator=(const value_type &i)
 253         {
 254                 r_ = g_ = b_ = a_ = i;
 255                 return *this;
 256         }*/
 257         //Color& operator=(const Color &c) { memcpy((void*)this, (const void*)&c, sizeof(Color)); return *this; }
 258
 259         //! Returns the RED component
 260         const value_type& get_r()const { return r_; }
 261
 262         //! Returns the GREEN component
 263         const value_type& get_g()const { return g_; }
 264
 265         //! Returns the BLUE component
 266         const value_type& get_b()const { return b_; }
 267
 268         //! Returns the amount of opacity (alpha)
 269         const value_type& get_a()const { return a_; }
 270
 271         //! Synonym for get_a(). \see get_a()
 272         const value_type& get_alpha()const { return get_a(); }
 273
 274         //! Converts a 2 character hex string \a s (00-ff) into a ColorReal (0.0-1.0)
 275         static ColorReal hex2real(String s);
 276
 277         //! Converts a ColorReal \a c (0.0-1.0) into a 2 character hex string (00-ff)
 278         static const String real2hex(ColorReal c);
 279
 280         //! Returns the color as a 6 character hex sting
 281         const String get_hex()const { return String(real2hex(r_)+real2hex(g_)+real2hex(b_)); }
 282
 283         //! Sets the color's R, G, and B from a 3 or 6 character hex string
 284         void set_hex(String& hex);
 285
 286         //! Sets the RED component to \a x
 287         Color& set_r(const value_type& x) { r_ = x; return *this; }
 288
 289         //! Sets the GREEN component to \a x
 290         Color& set_g(const value_type& x) { g_ = x; return *this; }
 291
 292         //! Sets the BLUE component to \a x
 293         Color& set_b(const value_type& x) { b_ = x; return *this; }
 294
 295         //! Sets the opacity (alpha) to \a x
 296         Color& set_a(const value_type& x) { a_ = x; return *this; }
 297
 298         //! Synonym for set_a(). \see set_a()
 299         Color& set_alpha(const value_type& x) { return set_a(x); }
 300
 301         //! Returns color's luminance
 302         float
 303         get_y() const
 304         {
 305                 return
 306                         (float)get_r()*EncodeYUV[0][0]+
 307                         (float)get_g()*EncodeYUV[0][1]+
 308                         (float)get_b()*EncodeYUV[0][2];
 309         }
 310
 311
 312         //! Returns U component of chromanance
 313         float
 314         get_u() const
 315         {
 316                 return
 317                         (float)get_r()*EncodeYUV[1][0]+
 318                         (float)get_g()*EncodeYUV[1][1]+
 319                         (float)get_b()*EncodeYUV[1][2];
 320         }
 321
 322
 323         //! Returns V component of chromanance
 324         float
 325         get_v() const
 326         {
 327                 return
 328                         (float)get_r()*EncodeYUV[2][0]+
 329                         (float)get_g()*EncodeYUV[2][1]+
 330                         (float)get_b()*EncodeYUV[2][2];
 331         }
 332
 333         //! Returns the color's saturation
 334         /*!     This is is the magnitude of the U and V components.
 335         **      \see set_s() */
 336         float
 337         get_s() const
 338         {
 339                 const float u(get_u()), v(get_v());
 340                 return sqrt(u*u+v*v);
 341         }
 342
 343         //! Sets the luminance (\a y) and chromanance (\a u and \a v)
 344         Color&
 345         set_yuv(const float &y, const float &u, const float &v)
 346         {
 347                 set_r(y*DecodeYUV[0][0]+u*DecodeYUV[0][1]+v*DecodeYUV[0][2]);
 348                 set_g(y*DecodeYUV[1][0]+u*DecodeYUV[1][1]+v*DecodeYUV[1][2]);
 349                 set_b(y*DecodeYUV[2][0]+u*DecodeYUV[2][1]+v*DecodeYUV[2][2]);
 350                 return *this;
 351         }
 352
 353         //! Sets color luminance
 354         Color& set_y(const float &y) { return set_yuv(y,get_u(),get_v()); }
 355
 356         //! Set U component of chromanance
 357         Color& set_u(const float &u) { return set_yuv(get_y(),u,get_v()); }
 358
 359         //! Set V component of chromanance
 360         Color& set_v(const float &v) { return set_yuv(get_y(),get_u(),v); }
 361
 362         //! Set the U and V components of chromanance
 363         Color& set_uv(const float& u, const float& v) { return set_yuv(get_y(),u,v); }
 364
 365         //! Sets the color's saturation
 366         /*!     \see get_s() */
 367         Color&
 368         set_s(const float &x)
 369         {
 370                 float u(get_u()), v(get_v());
 371                 const float s(sqrt(u*u+v*v));
 372                 if(s)
 373                 {
 374                         u=(u/s)*x;
 375                         v=(v/s)*x;
 376                         return set_uv(u,v);
 377                 }
 378                 return *this;
 379         }
 380
 381         //! YUV Color constructor
 382         static Color YUV(const float& y, const float& u, const float& v, const value_type& a=1)
 383                 { return Color().set_yuv(y,u,v).set_a(a); }
 384
 385         //! Returns the hue of the chromanance
 386         /*!     This is the angle of the U and V components.
 387         **      \see set_hue() */
 388         Angle
 389         get_hue() const
 390                 { return Angle::tan(get_u(),get_v()); }
 391
 392         //! Synonym for get_hue(). \see get_hue()
 393         Angle get_uv_angle() const { return get_hue(); }
 394
 395         //! Sets the color's hue
 396         /*!     \see get_hue() */
 397         Color&
 398         set_hue(const Angle& theta)
 399         {
 400                 const float s(get_s());
 401                 const float
 402                         u(s*(float)Angle::sin(theta).get()),
 403                         v(s*(float)Angle::cos(theta).get());
 404                 return set_uv(u,v);
 405         }
 406
 407         //! Synonym for set_hue(). \see set_hue()
 408         Color& set_uv_angle(const Angle& theta) { return set_hue(theta); }
 409
 410         //! Rotates the chromanance vector by amount specified by \a theta
 411         Color& rotate_uv(const Angle& theta)
 412         {
 413                 const float     a(Angle::sin(theta).get()),     b(Angle::cos(theta).get());
 414                 const float     u(get_u()),     v(get_v());
 415
 416                 return set_uv(b*u-a*v,a*u+b*v);
 417         }
 418
 419         //! Sets the luminance (\a y) and chromanance (\a s and \a theta).
 420         /*!     \param y Luminance
 421         **      \param s Saturation
 422         **      \param theta Hue */
 423         Color& set_yuv(const float& y, const float& s, const Angle& theta)
 424         {
 425                 return
 426                         set_yuv(
 427                                 y,
 428                                 s*(float)Angle::sin(theta).get(),
 429                                 s*(float)Angle::cos(theta).get()
 430                         );
 431         }
 432
 433         //! YUV color constructor where the chroma is in the saturation/hue form.
 434         /*!     \param y Luminance
 435         **      \param s Saturation
 436         **      \param theta Hue
 437         **      \param a Opacity (alpha) */
 438         static Color YUV(const float& y, const float& s, const Angle& theta, const value_type& a=1)
 439                 { return Color().set_yuv(y,s,theta).set_a(a); }
 440
 441
 442         //! Clamps a color so that its values are in range. Ignores attempting to visualize negative colors.
 443         Color clamped()const;
 444
 445         //! Clamps a color so that its values are in range.
 446         Color clamped_negative()const;
 447
 448         /* Preset Colors */
 449
 450         //! Preset Color Constructors
 451         //@{
 452 #ifdef HAS_VIMAGE
 453         static inline Color alpha() { return Color(0,0,0,0.0000001f); }
 454 #else
 455         static inline Color alpha() { return Color(0,0,0,0); }
 456 #endif
 457         static inline Color black() { return Color(0,0,0); }
 458         static inline Color white() { return Color(1,1,1); }
 459         static inline Color gray() { return Color(0.5f,0.5f,0.5f); }
 460         static inline Color magenta() { return Color(1,0,1); }
 461         static inline Color red() { return Color(1,0,0); }
 462         static inline Color green() { return Color(0,1,0); }
 463         static inline Color blue() { return Color(0,0,1); }
 464         static inline Color cyan() { return Color(0,1,1); }
 465         static inline Color yellow() { return Color(1,1,0); }
 466         //@}
 467
 468         //! \writeme
 469         enum BlendMethod
 470         {
 471                 BLEND_COMPOSITE=0,                      //!< Color A is composited onto B (Taking A's alpha into account)
 472                 BLEND_STRAIGHT=1,                       //!< Straight linear interpolation from A->B (Alpha ignored)
 473                 BLEND_ONTO=13,                          //!< Similar to BLEND_COMPOSITE, except that B's alpha is maintained
 474                 BLEND_STRAIGHT_ONTO=21,         //!< \deprecated \writeme
 475                 BLEND_BEHIND=12,                        //!< Similar to BLEND_COMPOSITE, except that B is composited onto A.
 476                 BLEND_SCREEN=16,                        //!< \writeme
 477                 BLEND_OVERLAY=20,                       //!< \writeme
 478                 BLEND_HARD_LIGHT=17,            //!< \writeme
 479                 BLEND_MULTIPLY=6,                       //!< Simple A*B.
 480                 BLEND_DIVIDE=7,                         //!< Simple B/A
 481                 BLEND_ADD=4,                            //!< Simple A+B.
 482                 BLEND_SUBTRACT=5,                       //!< Simple A-B.
 483                 BLEND_DIFFERENCE=18,            //!< Simple |A-B|.
 484                 BLEND_BRIGHTEN=2,                       //!< If composite is brighter than B, use composite. B otherwise.
 485                 BLEND_DARKEN=3,                         //!< If composite is darker than B, use composite. B otherwise.
 486                 BLEND_COLOR=8,                          //!< Preserves the U and V channels of color A
 487                 BLEND_HUE=9,                            //!< Preserves the angle of the UV vector of color A
 488                 BLEND_SATURATION=10,            //!< Preserves the magnitude of the UV Vector of color A
 489                 BLEND_LUMINANCE=11,                     //!< Preserves the Y channel of color A
 490
 491                 BLEND_ALPHA_BRIGHTEN=14,        //!< \deprecated If A is less opaque than B, use A
 492                 BLEND_ALPHA_DARKEN=15,          //!< \deprecated If A is more opaque than B, use B
 493                 BLEND_ALPHA_OVER=19,            //!< \deprecated multiply alphas and then straight blends using the amount
 494
 495                 BLEND_END=22                            //!< \internal
 496         };
 497
 498         /* Other */
 499         static Color blend(Color a, Color b,float amount,BlendMethod type=BLEND_COMPOSITE);
 500
 501         static bool is_onto(BlendMethod x)
 502         {
 503                 return x==BLEND_BRIGHTEN
 504                         || x==BLEND_DARKEN
 505                         || x==BLEND_ADD
 506                         || x==BLEND_SUBTRACT
 507                         || x==BLEND_MULTIPLY
 508                         || x==BLEND_DIVIDE
 509                         || x==BLEND_COLOR
 510                         || x==BLEND_HUE
 511                         || x==BLEND_SATURATION
 512                         || x==BLEND_LUMINANCE
 513                         || x==BLEND_ONTO
 514                         || x==BLEND_STRAIGHT_ONTO
 515                         || x==BLEND_SCREEN
 516                         || x==BLEND_OVERLAY
 517                         || x==BLEND_DIFFERENCE
 518                         || x==BLEND_HARD_LIGHT
 519                 ;
 520         }
 521
 522         //! a blending method is considered 'straight' if transparent pixels in the upper layer can affect the result of the blend
 523         static bool is_straight(BlendMethod x)
 524         {
 525                 return x==BLEND_STRAIGHT
 526                         || x==BLEND_STRAIGHT_ONTO
 527                         || x==BLEND_ALPHA_BRIGHTEN
 528                 ;
 529         }
 530 /*protected:
 531
 532         value_type& operator[](const int i)
 533         {
 534                 assert(i>=0);
 535                 assert(i<(signed)(sizeof(Color)/sizeof(value_type)));
 536                 return (&r_)[i];
 537         }
 538
 539         const value_type& operator[](const int i)const
 540         {
 541                 assert(i>=0);
 542                 assert(i<(signed)(sizeof(Color)/sizeof(value_type)));
 543                 return (&r_)[i];
 544         }
 545 */
 546 }; // END of class Color
 547
 548 #ifndef USE_HALF_TYPE
 549 typedef Color ColorAccumulator;
 550 #else
 551 class ColorAccumulator
 552 {
 553         friend class Color;
 554 public:
 555         typedef float value_type;
 556
 557 private:
 558         value_type a_, r_, g_, b_;
 559
 560 public:
 561
 562         ColorAccumulator &
 563         operator+=(const ColorAccumulator &rhs)
 564         {
 565                 r_+=rhs.r_;
 566                 g_+=rhs.g_;
 567                 b_+=rhs.b_;
 568                 a_+=rhs.a_;
 569                 return *this;
 570         }
 571
 572         ColorAccumulator &
 573         operator-=(const ColorAccumulator &rhs)
 574         {
 575                 r_-=rhs.r_;
 576                 g_-=rhs.g_;
 577                 b_-=rhs.b_;
 578                 a_-=rhs.a_;
 579                 return *this;
 580         }
 581
 582         ColorAccumulator &
 583         operator*=(const float &rhs)
 584         {
 585                 r_*=rhs;
 586                 g_*=rhs;
 587                 b_*=rhs;
 588                 a_*=rhs;
 589                 return *this;
 590         }
 591
 592         ColorAccumulator &
 593         operator/=(const float &rhs)
 594         {
 595                 const float temp(value_type(1)/rhs);
 596                 r_*=temp;
 597                 g_*=temp;
 598                 b_*=temp;
 599                 a_*=temp;
 600                 return *this;
 601         }
 602
 603         ColorAccumulator
 604         operator+(const ColorAccumulator &rhs)const
 605         { return Color(*this)+=rhs; }
 606
 607         ColorAccumulator
 608         operator-(const ColorAccumulator &rhs)const
 609         { return Color(*this)-=rhs; }
 610
 611         ColorAccumulator
 612         operator*(const float &rhs)const
 613         { return Color(*this)*=rhs; }
 614
 615         ColorAccumulator
 616         operator/(const float &rhs)const
 617         { return Color(*this)/=rhs; }
 618
 619         bool
 620         operator==(const ColorAccumulator &rhs)const
 621         { return r_==rhs.r_ && g_==rhs.g_ && b_==rhs.b_ && a_!=rhs.a_; }
 622
 623         bool
 624         operator!=(const ColorAccumulator &rhs)const
 625         { return r_!=rhs.r_ || g_!=rhs.g_ || b_!=rhs.b_ || a_!=rhs.a_; }
 626
 627         Color
 628         operator-()const
 629         { return ColorAccumulator(-r_,-g_,-b_,-a_); }
 630
 631         bool is_valid()const
 632         { return !isnan(r_) && !isnan(g_) && !isnan(b_) && !isnan(a_); }
 633
 634 public:
 635         ColorAccumulator() { }
 636
 637         /*!     \param R Red
 638         **      \param G Green
 639         **      \param B Blue
 640         **      \param A Opacity(alpha) */
 641         ColorAccumulator(const value_type& R, const value_type& G, const value_type& B, const value_type& A=1):
 642                 a_(A),
 643                 r_(R),
 644                 g_(G),
 645                 b_(B) { }
 646
 647         //!     Copy constructor
 648         ColorAccumulator(const ColorAccumulator& c):
 649                 a_(c.a_),
 650                 r_(c.r_),
 651                 g_(c.g_),
 652                 b_(c.b_) { }
 653
 654         //!     Converter
 655         ColorAccumulator(const Color& c):
 656                 a_(c.a_),
 657                 r_(c.r_),
 658                 g_(c.g_),
 659                 b_(c.b_) { }
 660
 661         //! Converter
 662         ColorAccumulator(int c): a_(c),r_(c), g_(c), b_(c) { }
 663
 664         //! Returns the RED component
 665         const value_type& get_r()const { return r_; }
 666
 667         //! Returns the GREEN component
 668         const value_type& get_g()const { return g_; }
 669
 670         //! Returns the BLUE component
 671         const value_type& get_b()const { return b_; }
 672
 673         //! Returns the amount of opacity (alpha)
 674         const value_type& get_a()const { return a_; }
 675
 676         //! Synonym for get_a(). \see get_a()
 677         const value_type& get_alpha()const { return get_a(); }
 678
 679         //! Sets the RED component to \a x
 680         ColorAccumulator& set_r(const value_type& x) { r_ = x; return *this; }
 681
 682         //! Sets the GREEN component to \a x
 683         ColorAccumulator& set_g(const value_type& x) { g_ = x; return *this; }
 684
 685         //! Sets the BLUE component to \a x
 686         ColorAccumulator& set_b(const value_type& x) { b_ = x; return *this; }
 687
 688         //! Sets the opacity (alpha) to \a x
 689         ColorAccumulator& set_a(const value_type& x) { a_ = x; return *this; }
 690
 691         //! Synonym for set_a(). \see set_a()
 692         ColorAccumulator& set_alpha(const value_type& x) { return set_a(x); }
 693 };
 694
 695 inline
 696 Color::Color(const ColorAccumulator& c):
 697         a_(c.a_),
 698         r_(c.r_),
 699         g_(c.g_),
 700         b_(c.b_) { }
 701
 702 #endif
 703
 704
 705
 706
 707
 708 enum PixelFormat
 709 {
 710 /* Bit  Descriptions (ON/OFF)
 711 ** ----+-------------
 712 ** 0    Color Channels (Gray/RGB)
 713 ** 1    Alpha Channel (WITH/WITHOUT)
 714 ** 2    ZDepth  (WITH/WITHOUT)
 715 ** 3    Endian (BGR/RGB)
 716 ** 4    Alpha Location (Start/End)
 717 ** 5    ZDepth Location (Start/End)
 718 ** 6    Alpha/ZDepth Arrangement (ZA,AZ)
 719 ** 7    Alpha Range (Inverted,Normal)
 720 ** 8    Z Range (Inverted,Normal)
 721 */
 722         PF_RGB=0,
 723         PF_GRAY=(1<<0),                 //!< If set, use one grayscale channel. If clear, use three channels for RGB
 724         PF_A=(1<<1),                    //!< If set, include alpha channel
 725         PF_Z=(1<<2),                    //!< If set, include ZDepth channel
 726         PF_BGR=(1<<3),                  //!< If set, reverse the order of the RGB channels
 727         PF_A_START=(1<<4),              //!< If set, alpha channel is before the color data. If clear, it is after.
 728         PF_Z_START=(1<<5),              //!< If set, ZDepth channel is before the color data. If clear, it is after.
 729         PF_ZA=(1<<6),                   //!< If set, the ZDepth channel will be in front of the alpha channel. If clear, they are reversed.
 730
 731         PF_A_INV=(1<<7),                //!< If set, the alpha channel is stored as 1.0-a
 732         PF_Z_INV=(1<<8),                //!< If set, the ZDepth channel is stored as 1.0-z
 733         PF_RAW_COLOR=(1<<9)+(1<<1)      //!< If set, the data represents a raw Color data structure, and all other bits are ignored.
 734 };
 735
 736 inline PixelFormat operator|(PixelFormat lhs, PixelFormat rhs)
 737         { return static_cast<PixelFormat>((int)lhs|(int)rhs); }
 738
 739 inline PixelFormat operator&(PixelFormat lhs, PixelFormat rhs)
 740         { return static_cast<PixelFormat>((int)lhs&(int)rhs); }
 741 #define FLAGS(x,y)              (((x)&(y))==(y))
 742
 743 //! Returns the number of channels that the given PixelFormat calls for
 744 inline int
 745 channels(PixelFormat x)
 746 {
 747         int chan=0;
 748         if(FLAGS(x,PF_GRAY))
 749                 ++chan;
 750         else
 751                 chan+=3;
 752         if(FLAGS(x,PF_A))
 753                 ++chan;
 754         if(FLAGS(x,PF_Z))
 755                 ++chan;
 756         if(FLAGS(x,PF_RAW_COLOR))
 757                 chan=sizeof(Color);
 758
 759         return chan;
 760 }
 761
 762 inline unsigned char *
 763 Color2PixelFormat(const Color &color, const PixelFormat &pf, unsigned char *out, const Gamma &gamma)
 764 {
 765         if(FLAGS(pf,PF_RAW_COLOR))
 766         {
 767                 Color *outcol=reinterpret_cast<Color *>(out);
 768                 *outcol=color;
 769                 out+=sizeof(color);
 770                 return out;
 771         }
 772
 773         int alpha=(int)((FLAGS(pf,PF_A_INV)?(-(float)color.get_a()+1):(float)color.get_a())*255);
 774         if(alpha<0)alpha=0;
 775         if(alpha>255)alpha=255;
 776
 777         if(FLAGS(pf,PF_ZA|PF_A_START|PF_Z_START))
 778         {
 779                 if(FLAGS(pf,PF_Z_START))
 780                         *out++/*=(unsigned char)(color.GetZ()*255.0f)*/;
 781                 if(FLAGS(pf,PF_A_START))
 782                         *out++=static_cast<unsigned char>(alpha);
 783         }
 784         else
 785         {
 786                 if(FLAGS(pf,PF_A_START))
 787                         *out++=static_cast<unsigned char>(alpha);
 788                 if(FLAGS(pf,PF_Z_START))
 789                         *out++/*=(unsigned char)(color.GetZ()*255.0f)*/;
 790
 791         }
 792
 793         if(FLAGS(pf,PF_GRAY))
 794                 *out++=static_cast<unsigned char>(gamma.g_F32_to_U8(color.get_y()));
 795         else
 796         {
 797                 if(FLAGS(pf,PF_BGR))
 798                 {
 799                         *out++=static_cast<unsigned char>(gamma.r_F32_to_U8(color.get_b()));
 800                         *out++=static_cast<unsigned char>(gamma.g_F32_to_U8(color.get_g()));
 801                         *out++=static_cast<unsigned char>(gamma.b_F32_to_U8(color.get_r()));
 802                 }
 803                 else
 804                 {
 805                         *out++=static_cast<unsigned char>(gamma.r_F32_to_U8(color.get_r()));
 806                         *out++=static_cast<unsigned char>(gamma.g_F32_to_U8(color.get_g()));
 807                         *out++=static_cast<unsigned char>(gamma.b_F32_to_U8(color.get_b()));
 808                 }
 809         }
 810
 811         if(FLAGS(pf,PF_ZA))
 812         {
 813                 if(!FLAGS(pf,PF_Z_START) && FLAGS(pf,PF_Z))
 814                         out++;//*out++=(unsigned char)(color.GetZ()*255.0f);
 815                 if(!FLAGS(pf,PF_A_START) && FLAGS(pf,PF_A))
 816                         *out++=static_cast<unsigned char>(alpha);
 817         }
 818         else
 819         {
 820                 if(!FLAGS(pf,PF_Z_START) && FLAGS(pf,PF_Z))
 821                         out++;//*out++=(unsigned char)(color.GetZ()*255.0f);
 822                 if(!FLAGS(pf,PF_A_START) && FLAGS(pf,PF_A))
 823                         *out++=static_cast<unsigned char>(alpha);
 824         }
 825         return out;
 826 }
 827
 828 inline void
 829 convert_color_format(unsigned char *dest, const Color *src, int w, PixelFormat pf,const Gamma &gamma)
 830 {
 831         assert(w>=0);
 832         while(w--)
 833                 dest=Color2PixelFormat((*(src++)).clamped(),pf,dest,gamma);
 834 }
 835
 836 inline const unsigned char *
 837 PixelFormat2Color(Color &color, const PixelFormat &pf,const unsigned char *out)
 838 {
 839         if(FLAGS(pf,PF_ZA|PF_A_START|PF_Z_START))
 840         {
 841                 if(FLAGS(pf,PF_Z_START))
 842                         out++;//color.SetZ((Color::value_type)*out++/255.0f);
 843                 if(FLAGS(pf,PF_A_START))
 844                         color.set_a((float)*out++/255);
 845         }
 846         else
 847         {
 848                 if(FLAGS(pf,PF_A_START))
 849                         color.set_a((float)*out++/255);
 850                 if(FLAGS(pf,PF_Z_START))
 851                         out++;//color.SetZ((Color::value_type)*out++/255.0f);
 852         }
 853
 854         if(FLAGS(pf,PF_GRAY))
 855                 color.set_yuv((float)*out++/255,0,0);
 856         else
 857         {
 858                 if(FLAGS(pf,PF_BGR))
 859                 {
 860                         color.set_b((float)*out++/255);
 861                         color.set_g((float)*out++/255);
 862                         color.set_r((float)*out++/255);
 863                 }
 864                 else
 865                 {
 866                         color.set_r((float)*out++/255);
 867                         color.set_g((float)*out++/255);
 868                         color.set_b((float)*out++/255);
 869                 }
 870         }
 871
 872         if(FLAGS(pf,PF_ZA))
 873         {
 874                 if(!FLAGS(pf,PF_Z_START) && FLAGS(pf,PF_Z))
 875                         out++;//color.SetZ((Color::value_type)*out++/255.0f);
 876                 if(!FLAGS(pf,PF_A_START) && FLAGS(pf,PF_A))
 877                         color.set_a((float)*out++/255);
 878         }
 879         else
 880         {
 881                 if(!FLAGS(pf,PF_A_START) && FLAGS(pf,PF_A))
 882                         color.set_a((float)*out++/255);
 883                 if(!FLAGS(pf,PF_Z_START) && FLAGS(pf,PF_Z))
 884                         out++;//color.SetZ((Color::value_type)*out++/255.0f);
 885         }
 886         return out;
 887 }
 888
 889
 890
 891 }; // END of namespace synfig
 892
 893 /* === E N D =============================================================== */
 894
 895 #endif