agg/inc/agg_color_gray.h

   1 //----------------------------------------------------------------------------
   2 // Anti-Grain Geometry - Version 2.3
   3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
   4 //
   5 // Permission to copy, use, modify, sell and distribute this software
   6 // is granted provided this copyright notice appears in all copies.
   7 // This software is provided "as is" without express or implied
   8 // warranty, and with no claim as to its suitability for any purpose.
   9 //
  10 //----------------------------------------------------------------------------
  11 // Contact: mcseem@antigrain.com
  12 //          mcseemagg@yahoo.com
  13 //          http://www.antigrain.com
  14 //----------------------------------------------------------------------------
  15 //
  16 // Adaptation for high precision colors has been sponsored by
  17 // Liberty Technology Systems, Inc., visit http://lib-sys.com
  18 //
  19 // Liberty Technology Systems, Inc. is the provider of
  20 // PostScript and PDF technology for software developers.
  21 //
  22 //----------------------------------------------------------------------------
  23 //
  24 // color types gray8, gray16
  25 //
  26 //----------------------------------------------------------------------------
  27
  28 #ifndef AGG_COLOR_GRAY_INCLUDED
  29 #define AGG_COLOR_GRAY_INCLUDED
  30
  31 #include "agg_basics.h"
  32 #include "agg_color_rgba.h"
  33
  34 namespace agg
  35 {
  36
  37     //===================================================================gray8
  38     struct gray8
  39     {
  40         typedef int8u  value_type;
  41         typedef int32u calc_type;
  42         typedef int32  long_type;
  43         enum
  44         {
  45             base_shift = 8,
  46             base_size  = 1 << base_shift,
  47             base_mask  = base_size - 1
  48         };
  49         typedef gray8 self_type;
  50
  51         value_type v;
  52         value_type a;
  53
  54         //--------------------------------------------------------------------
  55         gray8() {}
  56
  57         //--------------------------------------------------------------------
  58         gray8(unsigned v_, unsigned a_=base_mask) :
  59             v(int8u(v_)), a(int8u(a_)) {}
  60
  61         //--------------------------------------------------------------------
  62         gray8(const self_type& c, unsigned a_) :
  63             v(c.v), a(value_type(a_)) {}
  64
  65         //--------------------------------------------------------------------
  66         gray8(const rgba& c) :
  67             v(value_type((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask) + 0.5)),
  68             a(value_type(c.a * double(base_mask))) {}
  69
  70         //--------------------------------------------------------------------
  71         gray8(const rgba& c, double a_) :
  72             v(value_type((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask) + 0.5)),
  73             a(value_type(a_ * double(base_mask))) {}
  74
  75         //--------------------------------------------------------------------
  76         gray8(const rgba8& c) :
  77             v((c.r*77 + c.g*150 + c.b*29) >> 8),
  78             a(c.a) {}
  79
  80         //--------------------------------------------------------------------
  81         gray8(const rgba8& c, unsigned a_) :
  82             v((c.r*77 + c.g*150 + c.b*29) >> 8),
  83             a(a_) {}
  84
  85         //--------------------------------------------------------------------
  86         void clear()
  87         {
  88             v = a = 0;
  89         }
  90
  91         //--------------------------------------------------------------------
  92         const self_type& transparent()
  93         {
  94             a = 0;
  95             return *this;
  96         }
  97
  98         //--------------------------------------------------------------------
  99         void opacity(double a_)
 100         {
 101             if(a_ < 0.0) a_ = 0.0;
 102             if(a_ > 1.0) a_ = 1.0;
 103             a = value_type(a_ * double(base_mask));
 104         }
 105
 106         //--------------------------------------------------------------------
 107         double opacity() const
 108         {
 109             return double(a) / double(base_mask);
 110         }
 111
 112
 113         //--------------------------------------------------------------------
 114         const self_type& premultiply()
 115         {
 116             if(a == base_mask) return *this;
 117             if(a == 0)
 118             {
 119                 v = 0;
 120                 return *this;
 121             }
 122             v = value_type((calc_type(v) * a) >> base_shift);
 123             return *this;
 124         }
 125
 126         //--------------------------------------------------------------------
 127         const self_type& premultiply(unsigned a_)
 128         {
 129             if(a == base_mask && a_ >= base_mask) return *this;
 130             if(a == 0 || a_ == 0)
 131             {
 132                 v = a = 0;
 133                 return *this;
 134             }
 135             calc_type v_ = (calc_type(v) * a_) / a;
 136             v = value_type((v_ > a_) ? a_ : v_);
 137             a = value_type(a_);
 138             return *this;
 139         }
 140
 141         //--------------------------------------------------------------------
 142         const self_type& demultiply()
 143         {
 144             if(a == base_mask) return *this;
 145             if(a == 0)
 146             {
 147                 v = 0;
 148                 return *this;
 149             }
 150             calc_type v_ = (calc_type(v) * base_mask) / a;
 151             v = value_type((v_ > base_mask) ? base_mask : v_);
 152             return *this;
 153         }
 154
 155         //--------------------------------------------------------------------
 156         self_type gradient(self_type c, double k) const
 157         {
 158             self_type ret;
 159             calc_type ik = calc_type(k * base_size);
 160             ret.v = value_type(calc_type(v) + (((calc_type(c.v) - v) * ik) >> base_shift));
 161             ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
 162             return ret;
 163         }
 164
 165         //--------------------------------------------------------------------
 166         static self_type no_color() { return self_type(0,0); }
 167     };
 168
 169
 170     //-------------------------------------------------------------gray8_pre
 171     inline gray8 gray8_pre(unsigned v, unsigned a = gray8::base_mask)
 172     {
 173         return gray8(v,a).premultiply();
 174     }
 175     inline gray8 gray8_pre(const gray8& c, unsigned a)
 176     {
 177         return gray8(c,a).premultiply();
 178     }
 179     inline gray8 gray8_pre(const rgba& c)
 180     {
 181         return gray8(c).premultiply();
 182     }
 183     inline gray8 gray8_pre(const rgba& c, double a)
 184     {
 185         return gray8(c,a).premultiply();
 186     }
 187     inline gray8 gray8_pre(const rgba8& c)
 188     {
 189         return gray8(c).premultiply();
 190     }
 191     inline gray8 gray8_pre(const rgba8& c, unsigned a)
 192     {
 193         return gray8(c,a).premultiply();
 194     }
 195
 196
 197
 198
 199     //==================================================================gray16
 200     struct gray16
 201     {
 202         typedef int16u value_type;
 203         typedef int32u calc_type;
 204         typedef int64  long_type;
 205         enum
 206         {
 207             base_shift = 16,
 208             base_size  = 1 << base_shift,
 209             base_mask  = base_size - 1
 210         };
 211         typedef gray16 self_type;
 212
 213         value_type v;
 214         value_type a;
 215
 216         //--------------------------------------------------------------------
 217         gray16() {}
 218
 219         //--------------------------------------------------------------------
 220         gray16(unsigned v_, unsigned a_=base_mask) :
 221             v(int16u(v_)), a(int16u(a_)) {}
 222
 223         //--------------------------------------------------------------------
 224         gray16(const self_type& c, unsigned a_) :
 225             v(c.v), a(value_type(a_)) {}
 226
 227         //--------------------------------------------------------------------
 228         gray16(const rgba& c) :
 229             v(value_type((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask) + 0.5)),
 230             a(value_type(c.a * double(base_mask))) {}
 231
 232         //--------------------------------------------------------------------
 233         gray16(const rgba& c, double a_) :
 234             v(value_type((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask) + 0.5)),
 235             a(value_type(a_ * double(base_mask))) {}
 236
 237         //--------------------------------------------------------------------
 238         gray16(const rgba8& c) :
 239             v(c.r*77 + c.g*150 + c.b*29),
 240             a((value_type(c.a) << 8) | c.a) {}
 241
 242         //--------------------------------------------------------------------
 243         gray16(const rgba8& c, unsigned a_) :
 244             v(c.r*77 + c.g*150 + c.b*29),
 245             a((value_type(a_) << 8) | c.a) {}
 246
 247         //--------------------------------------------------------------------
 248         void clear()
 249         {
 250             v = a = 0;
 251         }
 252
 253         //--------------------------------------------------------------------
 254         const self_type& transparent()
 255         {
 256             a = 0;
 257             return *this;
 258         }
 259
 260         //--------------------------------------------------------------------
 261         void opacity(double a_)
 262         {
 263             if(a_ < 0.0) a_ = 0.0;
 264             if(a_ > 1.0) a_ = 1.0;
 265             a = value_type(a_ * double(base_mask));
 266         }
 267
 268         //--------------------------------------------------------------------
 269         double opacity() const
 270         {
 271             return double(a) / double(base_mask);
 272         }
 273
 274
 275         //--------------------------------------------------------------------
 276         const self_type& premultiply()
 277         {
 278             if(a == base_mask) return *this;
 279             if(a == 0)
 280             {
 281                 v = 0;
 282                 return *this;
 283             }
 284             v = value_type((calc_type(v) * a) >> base_shift);
 285             return *this;
 286         }
 287
 288         //--------------------------------------------------------------------
 289         const self_type& premultiply(unsigned a_)
 290         {
 291             if(a == base_mask && a_ >= base_mask) return *this;
 292             if(a == 0 || a_ == 0)
 293             {
 294                 v = a = 0;
 295                 return *this;
 296             }
 297             calc_type v_ = (calc_type(v) * a_) / a;
 298             v = value_type((v_ > a_) ? a_ : v_);
 299             a = value_type(a_);
 300             return *this;
 301         }
 302
 303         //--------------------------------------------------------------------
 304         const self_type& demultiply()
 305         {
 306             if(a == base_mask) return *this;
 307             if(a == 0)
 308             {
 309                 v = 0;
 310                 return *this;
 311             }
 312             calc_type v_ = (calc_type(v) * base_mask) / a;
 313             v = value_type((v_ > base_mask) ? base_mask : v_);
 314             return *this;
 315         }
 316
 317         //--------------------------------------------------------------------
 318         self_type gradient(self_type c, double k) const
 319         {
 320             self_type ret;
 321             calc_type ik = calc_type(k * base_size);
 322             ret.v = value_type(calc_type(v) + (((calc_type(c.v) - v) * ik) >> base_shift));
 323             ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
 324             return ret;
 325         }
 326
 327         //--------------------------------------------------------------------
 328         static self_type no_color() { return self_type(0,0); }
 329     };
 330
 331
 332     //------------------------------------------------------------gray16_pre
 333     inline gray16 gray16_pre(unsigned v, unsigned a = gray16::base_mask)
 334     {
 335         return gray16(v,a).premultiply();
 336     }
 337     inline gray16 gray16_pre(const gray16& c, unsigned a)
 338     {
 339         return gray16(c,a).premultiply();
 340     }
 341     inline gray16 gray16_pre(const rgba& c)
 342     {
 343         return gray16(c).premultiply();
 344     }
 345     inline gray16 gray16_pre(const rgba& c, double a)
 346     {
 347         return gray16(c,a).premultiply();
 348     }
 349     inline gray16 gray16_pre(const rgba8& c)
 350     {
 351         return gray16(c).premultiply();
 352     }
 353     inline gray16 gray16_pre(const rgba8& c, unsigned a)
 354     {
 355         return gray16(c,a).premultiply();
 356     }
 357
 358
 359 }
 360
 361
 362
 363
 364 #endif