git.maemo.org Git - opencv/blob - 3rdparty/include/OpenEXR/ImathColor.h

   1 ///////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
   4 // Digital Ltd. LLC
   5 //
   6 // All rights reserved.
   7 //
   8 // Redistribution and use in source and binary forms, with or without
   9 // modification, are permitted provided that the following conditions are
  10 // met:
  11 // *       Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 // *       Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 // *       Neither the name of Industrial Light & Magic nor the names of
  18 // its contributors may be used to endorse or promote products derived
  19 // from this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 //
  33 ///////////////////////////////////////////////////////////////////////////
  34
  35
  36
  37 #ifndef INCLUDED_IMATHCOLOR_H
  38 #define INCLUDED_IMATHCOLOR_H
  39
  40 //----------------------------------------------------
  41 //
  42 //      A three and four component color class template.
  43 //
  44 //----------------------------------------------------
  45
  46 #include "ImathVec.h"
  47 #include "half.h"
  48
  49 namespace Imath {
  50
  51
  52 template <class T>
  53 class Color3: public Vec3 <T>
  54 {
  55   public:
  56
  57     //-------------
  58     // Constructors
  59     //-------------
  60
  61     Color3 ();                  // no initialization
  62     explicit Color3 (T a);      // (a a a)
  63     Color3 (T a, T b, T c);     // (a b c)
  64
  65
  66     //---------------------------------
  67     // Copy constructors and assignment
  68     //---------------------------------
  69
  70     Color3 (const Color3 &c);
  71     template <class S> Color3 (const Vec3<S> &v);
  72
  73     const Color3 &      operator = (const Color3 &c);
  74
  75
  76     //------------------------
  77     // Component-wise addition
  78     //------------------------
  79
  80     const Color3 &      operator += (const Color3 &c);
  81     Color3              operator + (const Color3 &c) const;
  82
  83
  84     //---------------------------
  85     // Component-wise subtraction
  86     //---------------------------
  87
  88     const Color3 &      operator -= (const Color3 &c);
  89     Color3              operator - (const Color3 &c) const;
  90
  91
  92     //------------------------------------
  93     // Component-wise multiplication by -1
  94     //------------------------------------
  95
  96     Color3              operator - () const;
  97     const Color3 &      negate ();
  98
  99
 100     //------------------------------
 101     // Component-wise multiplication
 102     //------------------------------
 103
 104     const Color3 &      operator *= (const Color3 &c);
 105     const Color3 &      operator *= (T a);
 106     Color3              operator * (const Color3 &c) const;
 107     Color3              operator * (T a) const;
 108
 109
 110     //------------------------
 111     // Component-wise division
 112     //------------------------
 113
 114     const Color3 &      operator /= (const Color3 &c);
 115     const Color3 &      operator /= (T a);
 116     Color3              operator / (const Color3 &c) const;
 117     Color3              operator / (T a) const;
 118 };
 119
 120 template <class T> class Color4
 121 {
 122   public:
 123
 124     //-------------------
 125     // Access to elements
 126     //-------------------
 127
 128     T                   r, g, b, a;
 129
 130     T &                 operator [] (int i);
 131     const T &           operator [] (int i) const;
 132
 133
 134     //-------------
 135     // Constructors
 136     //-------------
 137
 138     Color4 ();                          // no initialization
 139     explicit Color4 (T a);              // (a a a a)
 140     Color4 (T a, T b, T c, T d);        // (a b c d)
 141
 142
 143     //---------------------------------
 144     // Copy constructors and assignment
 145     //---------------------------------
 146
 147     Color4 (const Color4 &v);
 148     template <class S> Color4 (const Color4<S> &v);
 149
 150     const Color4 &      operator = (const Color4 &v);
 151
 152
 153     //----------------------
 154     // Compatibility with Sb
 155     //----------------------
 156
 157     template <class S>
 158     void                setValue (S a, S b, S c, S d);
 159
 160     template <class S>
 161     void                setValue (const Color4<S> &v);
 162
 163     template <class S>
 164     void                getValue (S &a, S &b, S &c, S &d) const;
 165
 166     template <class S>
 167     void                getValue (Color4<S> &v) const;
 168
 169     T *                 getValue();
 170     const T *           getValue() const;
 171
 172
 173     //---------
 174     // Equality
 175     //---------
 176
 177     template <class S>
 178     bool                operator == (const Color4<S> &v) const;
 179
 180     template <class S>
 181     bool                operator != (const Color4<S> &v) const;
 182
 183
 184     //------------------------
 185     // Component-wise addition
 186     //------------------------
 187
 188     const Color4 &      operator += (const Color4 &v);
 189     Color4              operator + (const Color4 &v) const;
 190
 191
 192     //---------------------------
 193     // Component-wise subtraction
 194     //---------------------------
 195
 196     const Color4 &      operator -= (const Color4 &v);
 197     Color4              operator - (const Color4 &v) const;
 198
 199
 200     //------------------------------------
 201     // Component-wise multiplication by -1
 202     //------------------------------------
 203
 204     Color4              operator - () const;
 205     const Color4 &      negate ();
 206
 207
 208     //------------------------------
 209     // Component-wise multiplication
 210     //------------------------------
 211
 212     const Color4 &      operator *= (const Color4 &v);
 213     const Color4 &      operator *= (T a);
 214     Color4              operator * (const Color4 &v) const;
 215     Color4              operator * (T a) const;
 216
 217
 218     //------------------------
 219     // Component-wise division
 220     //------------------------
 221
 222     const Color4 &      operator /= (const Color4 &v);
 223     const Color4 &      operator /= (T a);
 224     Color4              operator / (const Color4 &v) const;
 225     Color4              operator / (T a) const;
 226
 227
 228     //----------------------------------------------------------
 229     // Number of dimensions, i.e. number of elements in a Color4
 230     //----------------------------------------------------------
 231
 232     static unsigned int dimensions() {return 4;}
 233
 234
 235     //-------------------------------------------------
 236     // Limitations of type T (see also class limits<T>)
 237     //-------------------------------------------------
 238
 239     static T            baseTypeMin()           {return limits<T>::min();}
 240     static T            baseTypeMax()           {return limits<T>::max();}
 241     static T            baseTypeSmallest()      {return limits<T>::smallest();}
 242     static T            baseTypeEpsilon()       {return limits<T>::epsilon();}
 243
 244
 245     //--------------------------------------------------------------
 246     // Base type -- in templates, which accept a parameter, V, which
 247     // could be a Color4<T>, you can refer to T as
 248     // V::BaseType
 249     //--------------------------------------------------------------
 250
 251     typedef T           BaseType;
 252 };
 253
 254 //--------------
 255 // Stream output
 256 //--------------
 257
 258 template <class T>
 259 std::ostream &  operator << (std::ostream &s, const Color4<T> &v);
 260
 261 //----------------------------------------------------
 262 // Reverse multiplication: S * Color4<T>
 263 //----------------------------------------------------
 264
 265 template <class S, class T> Color4<T>   operator * (S a, const Color4<T> &v);
 266
 267 //-------------------------
 268 // Typedefs for convenience
 269 //-------------------------
 270
 271 typedef Color3<float>           Color3f;
 272 typedef Color3<half>            Color3h;
 273 typedef Color3<unsigned char>   Color3c;
 274 typedef Color3<half>            C3h;
 275 typedef Color3<float>           C3f;
 276 typedef Color3<unsigned char>   C3c;
 277 typedef Color4<float>           Color4f;
 278 typedef Color4<half>            Color4h;
 279 typedef Color4<unsigned char>   Color4c;
 280 typedef Color4<float>           C4f;
 281 typedef Color4<half>            C4h;
 282 typedef Color4<unsigned char>   C4c;
 283 typedef unsigned int            PackedColor;
 284
 285
 286 //-------------------------
 287 // Implementation of Color3
 288 //-------------------------
 289
 290 template <class T>
 291 inline
 292 Color3<T>::Color3 (): Vec3 <T> ()
 293 {
 294     // empty
 295 }
 296
 297 template <class T>
 298 inline
 299 Color3<T>::Color3 (T a): Vec3 <T> (a)
 300 {
 301     // empty
 302 }
 303
 304 template <class T>
 305 inline
 306 Color3<T>::Color3 (T a, T b, T c): Vec3 <T> (a, b, c)
 307 {
 308     // empty
 309 }
 310
 311 template <class T>
 312 inline
 313 Color3<T>::Color3 (const Color3 &c): Vec3 <T> (c)
 314 {
 315     // empty
 316 }
 317
 318 template <class T>
 319 template <class S>
 320 inline
 321 Color3<T>::Color3 (const Vec3<S> &v): Vec3 <T> (v)
 322 {
 323     //empty
 324 }
 325
 326 template <class T>
 327 inline const Color3<T> &
 328 Color3<T>::operator = (const Color3 &c)
 329 {
 330     *((Vec3<T> *) this) = c;
 331     return *this;
 332 }
 333
 334 template <class T>
 335 inline const Color3<T> &
 336 Color3<T>::operator += (const Color3 &c)
 337 {
 338     *((Vec3<T> *) this) += c;
 339     return *this;
 340 }
 341
 342 template <class T>
 343 inline Color3<T>
 344 Color3<T>::operator + (const Color3 &c) const
 345 {
 346     return Color3 (*(Vec3<T> *)this + (const Vec3<T> &)c);
 347 }
 348
 349 template <class T>
 350 inline const Color3<T> &
 351 Color3<T>::operator -= (const Color3 &c)
 352 {
 353     *((Vec3<T> *) this) -= c;
 354     return *this;
 355 }
 356
 357 template <class T>
 358 inline Color3<T>
 359 Color3<T>::operator - (const Color3 &c) const
 360 {
 361     return Color3 (*(Vec3<T> *)this - (const Vec3<T> &)c);
 362 }
 363
 364 template <class T>
 365 inline Color3<T>
 366 Color3<T>::operator - () const
 367 {
 368     return Color3 (-(*(Vec3<T> *)this));
 369 }
 370
 371 template <class T>
 372 inline const Color3<T> &
 373 Color3<T>::negate ()
 374 {
 375     ((Vec3<T> *) this)->negate();
 376     return *this;
 377 }
 378
 379 template <class T>
 380 inline const Color3<T> &
 381 Color3<T>::operator *= (const Color3 &c)
 382 {
 383     *((Vec3<T> *) this) *= c;
 384     return *this;
 385 }
 386
 387 template <class T>
 388 inline const Color3<T> &
 389 Color3<T>::operator *= (T a)
 390 {
 391     *((Vec3<T> *) this) *= a;
 392     return *this;
 393 }
 394
 395 template <class T>
 396 inline Color3<T>
 397 Color3<T>::operator * (const Color3 &c) const
 398 {
 399     return Color3 (*(Vec3<T> *)this * (const Vec3<T> &)c);
 400 }
 401
 402 template <class T>
 403 inline Color3<T>
 404 Color3<T>::operator * (T a) const
 405 {
 406     return Color3 (*(Vec3<T> *)this * a);
 407 }
 408
 409 template <class T>
 410 inline const Color3<T> &
 411 Color3<T>::operator /= (const Color3 &c)
 412 {
 413     *((Vec3<T> *) this) /= c;
 414     return *this;
 415 }
 416
 417 template <class T>
 418 inline const Color3<T> &
 419 Color3<T>::operator /= (T a)
 420 {
 421     *((Vec3<T> *) this) /= a;
 422     return *this;
 423 }
 424
 425 template <class T>
 426 inline Color3<T>
 427 Color3<T>::operator / (const Color3 &c) const
 428 {
 429     return Color3 (*(Vec3<T> *)this / (const Vec3<T> &)c);
 430 }
 431
 432 template <class T>
 433 inline Color3<T>
 434 Color3<T>::operator / (T a) const
 435 {
 436     return Color3 (*(Vec3<T> *)this / a);
 437 }
 438
 439 //-----------------------
 440 // Implementation of Color4
 441 //-----------------------
 442
 443 template <class T>
 444 inline T &
 445 Color4<T>::operator [] (int i)
 446 {
 447     return (&r)[i];
 448 }
 449
 450 template <class T>
 451 inline const T &
 452 Color4<T>::operator [] (int i) const
 453 {
 454     return (&r)[i];
 455 }
 456
 457 template <class T>
 458 inline
 459 Color4<T>::Color4 ()
 460 {
 461     // empty
 462 }
 463
 464 template <class T>
 465 inline
 466 Color4<T>::Color4 (T x)
 467 {
 468     r = g = b = a = x;
 469 }
 470
 471 template <class T>
 472 inline
 473 Color4<T>::Color4 (T x, T y, T z, T w)
 474 {
 475     r = x;
 476     g = y;
 477     b = z;
 478     a = w;
 479 }
 480
 481 template <class T>
 482 inline
 483 Color4<T>::Color4 (const Color4 &v)
 484 {
 485     r = v.r;
 486     g = v.g;
 487     b = v.b;
 488     a = v.a;
 489 }
 490
 491 template <class T>
 492 template <class S>
 493 inline
 494 Color4<T>::Color4 (const Color4<S> &v)
 495 {
 496     r = T (v.r);
 497     g = T (v.g);
 498     b = T (v.b);
 499     a = T (v.a);
 500 }
 501
 502 template <class T>
 503 inline const Color4<T> &
 504 Color4<T>::operator = (const Color4 &v)
 505 {
 506     r = v.r;
 507     g = v.g;
 508     b = v.b;
 509     a = v.a;
 510     return *this;
 511 }
 512
 513 template <class T>
 514 template <class S>
 515 inline void
 516 Color4<T>::setValue (S x, S y, S z, S w)
 517 {
 518     r = T (x);
 519     g = T (y);
 520     b = T (z);
 521     a = T (w);
 522 }
 523
 524 template <class T>
 525 template <class S>
 526 inline void
 527 Color4<T>::setValue (const Color4<S> &v)
 528 {
 529     r = T (v.r);
 530     g = T (v.g);
 531     b = T (v.b);
 532     a = T (v.a);
 533 }
 534
 535 template <class T>
 536 template <class S>
 537 inline void
 538 Color4<T>::getValue (S &x, S &y, S &z, S &w) const
 539 {
 540     x = S (r);
 541     y = S (g);
 542     z = S (b);
 543     w = S (a);
 544 }
 545
 546 template <class T>
 547 template <class S>
 548 inline void
 549 Color4<T>::getValue (Color4<S> &v) const
 550 {
 551     v.r = S (r);
 552     v.g = S (g);
 553     v.b = S (b);
 554     v.a = S (a);
 555 }
 556
 557 template <class T>
 558 inline T *
 559 Color4<T>::getValue()
 560 {
 561     return (T *) &r;
 562 }
 563
 564 template <class T>
 565 inline const T *
 566 Color4<T>::getValue() const
 567 {
 568     return (const T *) &r;
 569 }
 570
 571 template <class T>
 572 template <class S>
 573 inline bool
 574 Color4<T>::operator == (const Color4<S> &v) const
 575 {
 576     return r == v.r && g == v.g && b == v.b && a == v.a;
 577 }
 578
 579 template <class T>
 580 template <class S>
 581 inline bool
 582 Color4<T>::operator != (const Color4<S> &v) const
 583 {
 584     return r != v.r || g != v.g || b != v.b || a != v.a;
 585 }
 586
 587 template <class T>
 588 inline const Color4<T> &
 589 Color4<T>::operator += (const Color4 &v)
 590 {
 591     r += v.r;
 592     g += v.g;
 593     b += v.b;
 594     a += v.a;
 595     return *this;
 596 }
 597
 598 template <class T>
 599 inline Color4<T>
 600 Color4<T>::operator + (const Color4 &v) const
 601 {
 602     return Color4 (r + v.r, g + v.g, b + v.b, a + v.a);
 603 }
 604
 605 template <class T>
 606 inline const Color4<T> &
 607 Color4<T>::operator -= (const Color4 &v)
 608 {
 609     r -= v.r;
 610     g -= v.g;
 611     b -= v.b;
 612     a -= v.a;
 613     return *this;
 614 }
 615
 616 template <class T>
 617 inline Color4<T>
 618 Color4<T>::operator - (const Color4 &v) const
 619 {
 620     return Color4 (r - v.r, g - v.g, b - v.b, a - v.a);
 621 }
 622
 623 template <class T>
 624 inline Color4<T>
 625 Color4<T>::operator - () const
 626 {
 627     return Color4 (-r, -g, -b, -a);
 628 }
 629
 630 template <class T>
 631 inline const Color4<T> &
 632 Color4<T>::negate ()
 633 {
 634     r = -r;
 635     g = -g;
 636     b = -b;
 637     a = -a;
 638     return *this;
 639 }
 640
 641 template <class T>
 642 inline const Color4<T> &
 643 Color4<T>::operator *= (const Color4 &v)
 644 {
 645     r *= v.r;
 646     g *= v.g;
 647     b *= v.b;
 648     a *= v.a;
 649     return *this;
 650 }
 651
 652 template <class T>
 653 inline const Color4<T> &
 654 Color4<T>::operator *= (T x)
 655 {
 656     r *= x;
 657     g *= x;
 658     b *= x;
 659     a *= x;
 660     return *this;
 661 }
 662
 663 template <class T>
 664 inline Color4<T>
 665 Color4<T>::operator * (const Color4 &v) const
 666 {
 667     return Color4 (r * v.r, g * v.g, b * v.b, a * v.a);
 668 }
 669
 670 template <class T>
 671 inline Color4<T>
 672 Color4<T>::operator * (T x) const
 673 {
 674     return Color4 (r * x, g * x, b * x, a * x);
 675 }
 676
 677 template <class T>
 678 inline const Color4<T> &
 679 Color4<T>::operator /= (const Color4 &v)
 680 {
 681     r /= v.r;
 682     g /= v.g;
 683     b /= v.b;
 684     a /= v.a;
 685     return *this;
 686 }
 687
 688 template <class T>
 689 inline const Color4<T> &
 690 Color4<T>::operator /= (T x)
 691 {
 692     r /= x;
 693     g /= x;
 694     b /= x;
 695     a /= x;
 696     return *this;
 697 }
 698
 699 template <class T>
 700 inline Color4<T>
 701 Color4<T>::operator / (const Color4 &v) const
 702 {
 703     return Color4 (r / v.r, g / v.g, b / v.b, a / v.a);
 704 }
 705
 706 template <class T>
 707 inline Color4<T>
 708 Color4<T>::operator / (T x) const
 709 {
 710     return Color4 (r / x, g / x, b / x, a / x);
 711 }
 712
 713
 714 template <class T>
 715 std::ostream &
 716 operator << (std::ostream &s, const Color4<T> &v)
 717 {
 718     return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')';
 719 }
 720
 721 //-----------------------------------------
 722 // Implementation of reverse multiplication
 723 //-----------------------------------------
 724
 725 template <class S, class T>
 726 inline Color4<T>
 727 operator * (S x, const Color4<T> &v)
 728 {
 729     return Color4<T> (x * v.r, x * v.g, x * v.b, x * v.a);
 730 }
 731
 732 } // namespace Imath
 733
 734 #endif