+++ /dev/null
-///////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
-// Digital Ltd. LLC
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Industrial Light & Magic nor the names of
-// its contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef INCLUDED_IMATHCOLOR_H
-#define INCLUDED_IMATHCOLOR_H
-
-//----------------------------------------------------
-//
-// A three and four component color class template.
-//
-//----------------------------------------------------
-
-#include "ImathVec.h"
-#include "half.h"
-
-namespace Imath {
-
-
-template <class T>
-class Color3: public Vec3 <T>
-{
- public:
-
- //-------------
- // Constructors
- //-------------
-
- Color3 (); // no initialization
- explicit Color3 (T a); // (a a a)
- Color3 (T a, T b, T c); // (a b c)
-
-
- //---------------------------------
- // Copy constructors and assignment
- //---------------------------------
-
- Color3 (const Color3 &c);
- template <class S> Color3 (const Vec3<S> &v);
-
- const Color3 & operator = (const Color3 &c);
-
-
- //------------------------
- // Component-wise addition
- //------------------------
-
- const Color3 & operator += (const Color3 &c);
- Color3 operator + (const Color3 &c) const;
-
-
- //---------------------------
- // Component-wise subtraction
- //---------------------------
-
- const Color3 & operator -= (const Color3 &c);
- Color3 operator - (const Color3 &c) const;
-
-
- //------------------------------------
- // Component-wise multiplication by -1
- //------------------------------------
-
- Color3 operator - () const;
- const Color3 & negate ();
-
-
- //------------------------------
- // Component-wise multiplication
- //------------------------------
-
- const Color3 & operator *= (const Color3 &c);
- const Color3 & operator *= (T a);
- Color3 operator * (const Color3 &c) const;
- Color3 operator * (T a) const;
-
-
- //------------------------
- // Component-wise division
- //------------------------
-
- const Color3 & operator /= (const Color3 &c);
- const Color3 & operator /= (T a);
- Color3 operator / (const Color3 &c) const;
- Color3 operator / (T a) const;
-};
-
-template <class T> class Color4
-{
- public:
-
- //-------------------
- // Access to elements
- //-------------------
-
- T r, g, b, a;
-
- T & operator [] (int i);
- const T & operator [] (int i) const;
-
-
- //-------------
- // Constructors
- //-------------
-
- Color4 (); // no initialization
- explicit Color4 (T a); // (a a a a)
- Color4 (T a, T b, T c, T d); // (a b c d)
-
-
- //---------------------------------
- // Copy constructors and assignment
- //---------------------------------
-
- Color4 (const Color4 &v);
- template <class S> Color4 (const Color4<S> &v);
-
- const Color4 & operator = (const Color4 &v);
-
-
- //----------------------
- // Compatibility with Sb
- //----------------------
-
- template <class S>
- void setValue (S a, S b, S c, S d);
-
- template <class S>
- void setValue (const Color4<S> &v);
-
- template <class S>
- void getValue (S &a, S &b, S &c, S &d) const;
-
- template <class S>
- void getValue (Color4<S> &v) const;
-
- T * getValue();
- const T * getValue() const;
-
-
- //---------
- // Equality
- //---------
-
- template <class S>
- bool operator == (const Color4<S> &v) const;
-
- template <class S>
- bool operator != (const Color4<S> &v) const;
-
-
- //------------------------
- // Component-wise addition
- //------------------------
-
- const Color4 & operator += (const Color4 &v);
- Color4 operator + (const Color4 &v) const;
-
-
- //---------------------------
- // Component-wise subtraction
- //---------------------------
-
- const Color4 & operator -= (const Color4 &v);
- Color4 operator - (const Color4 &v) const;
-
-
- //------------------------------------
- // Component-wise multiplication by -1
- //------------------------------------
-
- Color4 operator - () const;
- const Color4 & negate ();
-
-
- //------------------------------
- // Component-wise multiplication
- //------------------------------
-
- const Color4 & operator *= (const Color4 &v);
- const Color4 & operator *= (T a);
- Color4 operator * (const Color4 &v) const;
- Color4 operator * (T a) const;
-
-
- //------------------------
- // Component-wise division
- //------------------------
-
- const Color4 & operator /= (const Color4 &v);
- const Color4 & operator /= (T a);
- Color4 operator / (const Color4 &v) const;
- Color4 operator / (T a) const;
-
-
- //----------------------------------------------------------
- // Number of dimensions, i.e. number of elements in a Color4
- //----------------------------------------------------------
-
- static unsigned int dimensions() {return 4;}
-
-
- //-------------------------------------------------
- // Limitations of type T (see also class limits<T>)
- //-------------------------------------------------
-
- static T baseTypeMin() {return limits<T>::min();}
- static T baseTypeMax() {return limits<T>::max();}
- static T baseTypeSmallest() {return limits<T>::smallest();}
- static T baseTypeEpsilon() {return limits<T>::epsilon();}
-
-
- //--------------------------------------------------------------
- // Base type -- in templates, which accept a parameter, V, which
- // could be a Color4<T>, you can refer to T as
- // V::BaseType
- //--------------------------------------------------------------
-
- typedef T BaseType;
-};
-
-//--------------
-// Stream output
-//--------------
-
-template <class T>
-std::ostream & operator << (std::ostream &s, const Color4<T> &v);
-
-//----------------------------------------------------
-// Reverse multiplication: S * Color4<T>
-//----------------------------------------------------
-
-template <class S, class T> Color4<T> operator * (S a, const Color4<T> &v);
-
-//-------------------------
-// Typedefs for convenience
-//-------------------------
-
-typedef Color3<float> Color3f;
-typedef Color3<half> Color3h;
-typedef Color3<unsigned char> Color3c;
-typedef Color3<half> C3h;
-typedef Color3<float> C3f;
-typedef Color3<unsigned char> C3c;
-typedef Color4<float> Color4f;
-typedef Color4<half> Color4h;
-typedef Color4<unsigned char> Color4c;
-typedef Color4<float> C4f;
-typedef Color4<half> C4h;
-typedef Color4<unsigned char> C4c;
-typedef unsigned int PackedColor;
-
-
-//-------------------------
-// Implementation of Color3
-//-------------------------
-
-template <class T>
-inline
-Color3<T>::Color3 (): Vec3 <T> ()
-{
- // empty
-}
-
-template <class T>
-inline
-Color3<T>::Color3 (T a): Vec3 <T> (a)
-{
- // empty
-}
-
-template <class T>
-inline
-Color3<T>::Color3 (T a, T b, T c): Vec3 <T> (a, b, c)
-{
- // empty
-}
-
-template <class T>
-inline
-Color3<T>::Color3 (const Color3 &c): Vec3 <T> (c)
-{
- // empty
-}
-
-template <class T>
-template <class S>
-inline
-Color3<T>::Color3 (const Vec3<S> &v): Vec3 <T> (v)
-{
- //empty
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator = (const Color3 &c)
-{
- *((Vec3<T> *) this) = c;
- return *this;
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator += (const Color3 &c)
-{
- *((Vec3<T> *) this) += c;
- return *this;
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator + (const Color3 &c) const
-{
- return Color3 (*(Vec3<T> *)this + (const Vec3<T> &)c);
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator -= (const Color3 &c)
-{
- *((Vec3<T> *) this) -= c;
- return *this;
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator - (const Color3 &c) const
-{
- return Color3 (*(Vec3<T> *)this - (const Vec3<T> &)c);
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator - () const
-{
- return Color3 (-(*(Vec3<T> *)this));
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::negate ()
-{
- ((Vec3<T> *) this)->negate();
- return *this;
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator *= (const Color3 &c)
-{
- *((Vec3<T> *) this) *= c;
- return *this;
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator *= (T a)
-{
- *((Vec3<T> *) this) *= a;
- return *this;
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator * (const Color3 &c) const
-{
- return Color3 (*(Vec3<T> *)this * (const Vec3<T> &)c);
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator * (T a) const
-{
- return Color3 (*(Vec3<T> *)this * a);
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator /= (const Color3 &c)
-{
- *((Vec3<T> *) this) /= c;
- return *this;
-}
-
-template <class T>
-inline const Color3<T> &
-Color3<T>::operator /= (T a)
-{
- *((Vec3<T> *) this) /= a;
- return *this;
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator / (const Color3 &c) const
-{
- return Color3 (*(Vec3<T> *)this / (const Vec3<T> &)c);
-}
-
-template <class T>
-inline Color3<T>
-Color3<T>::operator / (T a) const
-{
- return Color3 (*(Vec3<T> *)this / a);
-}
-
-//-----------------------
-// Implementation of Color4
-//-----------------------
-
-template <class T>
-inline T &
-Color4<T>::operator [] (int i)
-{
- return (&r)[i];
-}
-
-template <class T>
-inline const T &
-Color4<T>::operator [] (int i) const
-{
- return (&r)[i];
-}
-
-template <class T>
-inline
-Color4<T>::Color4 ()
-{
- // empty
-}
-
-template <class T>
-inline
-Color4<T>::Color4 (T x)
-{
- r = g = b = a = x;
-}
-
-template <class T>
-inline
-Color4<T>::Color4 (T x, T y, T z, T w)
-{
- r = x;
- g = y;
- b = z;
- a = w;
-}
-
-template <class T>
-inline
-Color4<T>::Color4 (const Color4 &v)
-{
- r = v.r;
- g = v.g;
- b = v.b;
- a = v.a;
-}
-
-template <class T>
-template <class S>
-inline
-Color4<T>::Color4 (const Color4<S> &v)
-{
- r = T (v.r);
- g = T (v.g);
- b = T (v.b);
- a = T (v.a);
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator = (const Color4 &v)
-{
- r = v.r;
- g = v.g;
- b = v.b;
- a = v.a;
- return *this;
-}
-
-template <class T>
-template <class S>
-inline void
-Color4<T>::setValue (S x, S y, S z, S w)
-{
- r = T (x);
- g = T (y);
- b = T (z);
- a = T (w);
-}
-
-template <class T>
-template <class S>
-inline void
-Color4<T>::setValue (const Color4<S> &v)
-{
- r = T (v.r);
- g = T (v.g);
- b = T (v.b);
- a = T (v.a);
-}
-
-template <class T>
-template <class S>
-inline void
-Color4<T>::getValue (S &x, S &y, S &z, S &w) const
-{
- x = S (r);
- y = S (g);
- z = S (b);
- w = S (a);
-}
-
-template <class T>
-template <class S>
-inline void
-Color4<T>::getValue (Color4<S> &v) const
-{
- v.r = S (r);
- v.g = S (g);
- v.b = S (b);
- v.a = S (a);
-}
-
-template <class T>
-inline T *
-Color4<T>::getValue()
-{
- return (T *) &r;
-}
-
-template <class T>
-inline const T *
-Color4<T>::getValue() const
-{
- return (const T *) &r;
-}
-
-template <class T>
-template <class S>
-inline bool
-Color4<T>::operator == (const Color4<S> &v) const
-{
- return r == v.r && g == v.g && b == v.b && a == v.a;
-}
-
-template <class T>
-template <class S>
-inline bool
-Color4<T>::operator != (const Color4<S> &v) const
-{
- return r != v.r || g != v.g || b != v.b || a != v.a;
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator += (const Color4 &v)
-{
- r += v.r;
- g += v.g;
- b += v.b;
- a += v.a;
- return *this;
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator + (const Color4 &v) const
-{
- return Color4 (r + v.r, g + v.g, b + v.b, a + v.a);
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator -= (const Color4 &v)
-{
- r -= v.r;
- g -= v.g;
- b -= v.b;
- a -= v.a;
- return *this;
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator - (const Color4 &v) const
-{
- return Color4 (r - v.r, g - v.g, b - v.b, a - v.a);
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator - () const
-{
- return Color4 (-r, -g, -b, -a);
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::negate ()
-{
- r = -r;
- g = -g;
- b = -b;
- a = -a;
- return *this;
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator *= (const Color4 &v)
-{
- r *= v.r;
- g *= v.g;
- b *= v.b;
- a *= v.a;
- return *this;
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator *= (T x)
-{
- r *= x;
- g *= x;
- b *= x;
- a *= x;
- return *this;
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator * (const Color4 &v) const
-{
- return Color4 (r * v.r, g * v.g, b * v.b, a * v.a);
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator * (T x) const
-{
- return Color4 (r * x, g * x, b * x, a * x);
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator /= (const Color4 &v)
-{
- r /= v.r;
- g /= v.g;
- b /= v.b;
- a /= v.a;
- return *this;
-}
-
-template <class T>
-inline const Color4<T> &
-Color4<T>::operator /= (T x)
-{
- r /= x;
- g /= x;
- b /= x;
- a /= x;
- return *this;
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator / (const Color4 &v) const
-{
- return Color4 (r / v.r, g / v.g, b / v.b, a / v.a);
-}
-
-template <class T>
-inline Color4<T>
-Color4<T>::operator / (T x) const
-{
- return Color4 (r / x, g / x, b / x, a / x);
-}
-
-
-template <class T>
-std::ostream &
-operator << (std::ostream &s, const Color4<T> &v)
-{
- return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')';
-}
-
-//-----------------------------------------
-// Implementation of reverse multiplication
-//-----------------------------------------
-
-template <class S, class T>
-inline Color4<T>
-operator * (S x, const Color4<T> &v)
-{
- return Color4<T> (x * v.r, x * v.g, x * v.b, x * v.a);
-}
-
-} // namespace Imath
-
-#endif
projects / opencv / blobdiff