--- /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