--- /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_IMATHVEC_H
+#define INCLUDED_IMATHVEC_H
+
+//----------------------------------------------------
+//
+// 2D and 3D point/vector class templates!
+//
+//----------------------------------------------------
+
+#include "ImathExc.h"
+#include "ImathLimits.h"
+#include "ImathMath.h"
+
+#include <iostream>
+
+#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
+// suppress exception specification warnings
+#pragma warning(disable:4290)
+#endif
+
+
+namespace Imath {
+
+
+template <class T> class Vec2
+{
+ public:
+
+ //-------------------
+ // Access to elements
+ //-------------------
+
+ T x, y;
+
+ T & operator [] (int i);
+ const T & operator [] (int i) const;
+
+
+ //-------------
+ // Constructors
+ //-------------
+
+ Vec2 (); // no initialization
+ explicit Vec2 (T a); // (a a)
+ Vec2 (T a, T b); // (a b)
+
+
+ //---------------------------------
+ // Copy constructors and assignment
+ //---------------------------------
+
+ Vec2 (const Vec2 &v);
+ template <class S> Vec2 (const Vec2<S> &v);
+
+ const Vec2 & operator = (const Vec2 &v);
+
+
+ //----------------------
+ // Compatibility with Sb
+ //----------------------
+
+ template <class S>
+ void setValue (S a, S b);
+
+ template <class S>
+ void setValue (const Vec2<S> &v);
+
+ template <class S>
+ void getValue (S &a, S &b) const;
+
+ template <class S>
+ void getValue (Vec2<S> &v) const;
+
+ T * getValue ();
+ const T * getValue () const;
+
+
+ //---------
+ // Equality
+ //---------
+
+ template <class S>
+ bool operator == (const Vec2<S> &v) const;
+
+ template <class S>
+ bool operator != (const Vec2<S> &v) const;
+
+
+ //-----------------------------------------------------------------------
+ // Compare two vectors and test if they are "approximately equal":
+ //
+ // equalWithAbsError (v, e)
+ //
+ // Returns true if the coefficients of this and v are the same with
+ // an absolute error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - v[i]) <= e
+ //
+ // equalWithRelError (v, e)
+ //
+ // Returns true if the coefficients of this and v are the same with
+ // a relative error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - v[i]) <= e * abs (this[i])
+ //-----------------------------------------------------------------------
+
+ bool equalWithAbsError (const Vec2<T> &v, T e) const;
+ bool equalWithRelError (const Vec2<T> &v, T e) const;
+
+ //------------
+ // Dot product
+ //------------
+
+ T dot (const Vec2 &v) const;
+ T operator ^ (const Vec2 &v) const;
+
+
+ //------------------------------------------------
+ // Right-handed cross product, i.e. z component of
+ // Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0)
+ //------------------------------------------------
+
+ T cross (const Vec2 &v) const;
+ T operator % (const Vec2 &v) const;
+
+
+ //------------------------
+ // Component-wise addition
+ //------------------------
+
+ const Vec2 & operator += (const Vec2 &v);
+ Vec2 operator + (const Vec2 &v) const;
+
+
+ //---------------------------
+ // Component-wise subtraction
+ //---------------------------
+
+ const Vec2 & operator -= (const Vec2 &v);
+ Vec2 operator - (const Vec2 &v) const;
+
+
+ //------------------------------------
+ // Component-wise multiplication by -1
+ //------------------------------------
+
+ Vec2 operator - () const;
+ const Vec2 & negate ();
+
+
+ //------------------------------
+ // Component-wise multiplication
+ //------------------------------
+
+ const Vec2 & operator *= (const Vec2 &v);
+ const Vec2 & operator *= (T a);
+ Vec2 operator * (const Vec2 &v) const;
+ Vec2 operator * (T a) const;
+
+
+ //------------------------
+ // Component-wise division
+ //------------------------
+
+ const Vec2 & operator /= (const Vec2 &v);
+ const Vec2 & operator /= (T a);
+ Vec2 operator / (const Vec2 &v) const;
+ Vec2 operator / (T a) const;
+
+
+ //----------------------------------------------------------------
+ // Length and normalization: If v.length() is 0.0, v.normalize()
+ // and v.normalized() produce a null vector; v.normalizeExc() and
+ // v.normalizedExc() throw a NullVecExc.
+ // v.normalizeNonNull() and v.normalizedNonNull() are slightly
+ // faster than the other normalization routines, but if v.length()
+ // is 0.0, the result is undefined.
+ //----------------------------------------------------------------
+
+ T length () const;
+ T length2 () const;
+
+ const Vec2 & normalize (); // modifies *this
+ const Vec2 & normalizeExc () throw (Iex::MathExc);
+ const Vec2 & normalizeNonNull ();
+
+ Vec2<T> normalized () const; // does not modify *this
+ Vec2<T> normalizedExc () const throw (Iex::MathExc);
+ Vec2<T> normalizedNonNull () const;
+
+
+ //--------------------------------------------------------
+ // Number of dimensions, i.e. number of elements in a Vec2
+ //--------------------------------------------------------
+
+ static unsigned int dimensions() {return 2;}
+
+
+ //-------------------------------------------------
+ // 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 either a Vec2<T> or a Vec3<T>, you can refer to T as
+ // V::BaseType
+ //--------------------------------------------------------------
+
+ typedef T BaseType;
+};
+
+
+template <class T> class Vec3
+{
+ public:
+
+ //-------------------
+ // Access to elements
+ //-------------------
+
+ T x, y, z;
+
+ T & operator [] (int i);
+ const T & operator [] (int i) const;
+
+
+ //-------------
+ // Constructors
+ //-------------
+
+ Vec3 (); // no initialization
+ explicit Vec3 (T a); // (a a a)
+ Vec3 (T a, T b, T c); // (a b c)
+
+
+ //---------------------------------
+ // Copy constructors and assignment
+ //---------------------------------
+
+ Vec3 (const Vec3 &v);
+ template <class S> Vec3 (const Vec3<S> &v);
+
+ const Vec3 & operator = (const Vec3 &v);
+
+
+ //----------------------
+ // Compatibility with Sb
+ //----------------------
+
+ template <class S>
+ void setValue (S a, S b, S c);
+
+ template <class S>
+ void setValue (const Vec3<S> &v);
+
+ template <class S>
+ void getValue (S &a, S &b, S &c) const;
+
+ template <class S>
+ void getValue (Vec3<S> &v) const;
+
+ T * getValue();
+ const T * getValue() const;
+
+
+ //---------
+ // Equality
+ //---------
+
+ template <class S>
+ bool operator == (const Vec3<S> &v) const;
+
+ template <class S>
+ bool operator != (const Vec3<S> &v) const;
+
+ //-----------------------------------------------------------------------
+ // Compare two vectors and test if they are "approximately equal":
+ //
+ // equalWithAbsError (v, e)
+ //
+ // Returns true if the coefficients of this and v are the same with
+ // an absolute error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - v[i]) <= e
+ //
+ // equalWithRelError (v, e)
+ //
+ // Returns true if the coefficients of this and v are the same with
+ // a relative error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - v[i]) <= e * abs (this[i])
+ //-----------------------------------------------------------------------
+
+ bool equalWithAbsError (const Vec3<T> &v, T e) const;
+ bool equalWithRelError (const Vec3<T> &v, T e) const;
+
+ //------------
+ // Dot product
+ //------------
+
+ T dot (const Vec3 &v) const;
+ T operator ^ (const Vec3 &v) const;
+
+
+ //---------------------------
+ // Right-handed cross product
+ //---------------------------
+
+ Vec3 cross (const Vec3 &v) const;
+ const Vec3 & operator %= (const Vec3 &v);
+ Vec3 operator % (const Vec3 &v) const;
+
+
+ //------------------------
+ // Component-wise addition
+ //------------------------
+
+ const Vec3 & operator += (const Vec3 &v);
+ Vec3 operator + (const Vec3 &v) const;
+
+
+ //---------------------------
+ // Component-wise subtraction
+ //---------------------------
+
+ const Vec3 & operator -= (const Vec3 &v);
+ Vec3 operator - (const Vec3 &v) const;
+
+
+ //------------------------------------
+ // Component-wise multiplication by -1
+ //------------------------------------
+
+ Vec3 operator - () const;
+ const Vec3 & negate ();
+
+
+ //------------------------------
+ // Component-wise multiplication
+ //------------------------------
+
+ const Vec3 & operator *= (const Vec3 &v);
+ const Vec3 & operator *= (T a);
+ Vec3 operator * (const Vec3 &v) const;
+ Vec3 operator * (T a) const;
+
+
+ //------------------------
+ // Component-wise division
+ //------------------------
+
+ const Vec3 & operator /= (const Vec3 &v);
+ const Vec3 & operator /= (T a);
+ Vec3 operator / (const Vec3 &v) const;
+ Vec3 operator / (T a) const;
+
+
+ //----------------------------------------------------------------
+ // Length and normalization: If v.length() is 0.0, v.normalize()
+ // and v.normalized() produce a null vector; v.normalizeExc() and
+ // v.normalizedExc() throw a NullVecExc.
+ // v.normalizeNonNull() and v.normalizedNonNull() are slightly
+ // faster than the other normalization routines, but if v.length()
+ // is 0.0, the result is undefined.
+ //----------------------------------------------------------------
+
+ T length () const;
+ T length2 () const;
+
+ const Vec3 & normalize (); // modifies *this
+ const Vec3 & normalizeExc () throw (Iex::MathExc);
+ const Vec3 & normalizeNonNull ();
+
+ Vec3<T> normalized () const; // does not modify *this
+ Vec3<T> normalizedExc () const throw (Iex::MathExc);
+ Vec3<T> normalizedNonNull () const;
+
+
+ //--------------------------------------------------------
+ // Number of dimensions, i.e. number of elements in a Vec3
+ //--------------------------------------------------------
+
+ static unsigned int dimensions() {return 3;}
+
+
+ //-------------------------------------------------
+ // 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 either a Vec2<T> or a Vec3<T>, you can refer to T as
+ // V::BaseType
+ //--------------------------------------------------------------
+
+ typedef T BaseType;
+};
+
+
+//--------------
+// Stream output
+//--------------
+
+template <class T>
+std::ostream & operator << (std::ostream &s, const Vec2<T> &v);
+
+template <class T>
+std::ostream & operator << (std::ostream &s, const Vec3<T> &v);
+
+
+//----------------------------------------------------
+// Reverse multiplication: S * Vec2<T> and S * Vec3<T>
+//----------------------------------------------------
+
+template <class T> Vec2<T> operator * (T a, const Vec2<T> &v);
+template <class T> Vec3<T> operator * (T a, const Vec3<T> &v);
+
+
+//-------------------------
+// Typedefs for convenience
+//-------------------------
+
+typedef Vec2 <short> V2s;
+typedef Vec2 <int> V2i;
+typedef Vec2 <float> V2f;
+typedef Vec2 <double> V2d;
+typedef Vec3 <short> V3s;
+typedef Vec3 <int> V3i;
+typedef Vec3 <float> V3f;
+typedef Vec3 <double> V3d;
+
+
+//-------------------------------------------------------------------
+// Specializations for Vec2<short>, Vec2<int>, Vec3<short>, Vec3<int>
+//-------------------------------------------------------------------
+
+// Vec2<short>
+
+template <> short
+Vec2<short>::length () const;
+
+template <> const Vec2<short> &
+Vec2<short>::normalize ();
+
+template <> const Vec2<short> &
+Vec2<short>::normalizeExc () throw (Iex::MathExc);
+
+template <> const Vec2<short> &
+Vec2<short>::normalizeNonNull ();
+
+template <> Vec2<short>
+Vec2<short>::normalized () const;
+
+template <> Vec2<short>
+Vec2<short>::normalizedExc () const throw (Iex::MathExc);
+
+template <> Vec2<short>
+Vec2<short>::normalizedNonNull () const;
+
+
+// Vec2<int>
+
+template <> int
+Vec2<int>::length () const;
+
+template <> const Vec2<int> &
+Vec2<int>::normalize ();
+
+template <> const Vec2<int> &
+Vec2<int>::normalizeExc () throw (Iex::MathExc);
+
+template <> const Vec2<int> &
+Vec2<int>::normalizeNonNull ();
+
+template <> Vec2<int>
+Vec2<int>::normalized () const;
+
+template <> Vec2<int>
+Vec2<int>::normalizedExc () const throw (Iex::MathExc);
+
+template <> Vec2<int>
+Vec2<int>::normalizedNonNull () const;
+
+
+// Vec3<short>
+
+template <> short
+Vec3<short>::length () const;
+
+template <> const Vec3<short> &
+Vec3<short>::normalize ();
+
+template <> const Vec3<short> &
+Vec3<short>::normalizeExc () throw (Iex::MathExc);
+
+template <> const Vec3<short> &
+Vec3<short>::normalizeNonNull ();
+
+template <> Vec3<short>
+Vec3<short>::normalized () const;
+
+template <> Vec3<short>
+Vec3<short>::normalizedExc () const throw (Iex::MathExc);
+
+template <> Vec3<short>
+Vec3<short>::normalizedNonNull () const;
+
+
+// Vec3<int>
+
+template <> int
+Vec3<int>::length () const;
+
+template <> const Vec3<int> &
+Vec3<int>::normalize ();
+
+template <> const Vec3<int> &
+Vec3<int>::normalizeExc () throw (Iex::MathExc);
+
+template <> const Vec3<int> &
+Vec3<int>::normalizeNonNull ();
+
+template <> Vec3<int>
+Vec3<int>::normalized () const;
+
+template <> Vec3<int>
+Vec3<int>::normalizedExc () const throw (Iex::MathExc);
+
+template <> Vec3<int>
+Vec3<int>::normalizedNonNull () const;
+
+
+//------------------------
+// Implementation of Vec2:
+//------------------------
+
+template <class T>
+inline T &
+Vec2<T>::operator [] (int i)
+{
+ return (&x)[i];
+}
+
+template <class T>
+inline const T &
+Vec2<T>::operator [] (int i) const
+{
+ return (&x)[i];
+}
+
+template <class T>
+inline
+Vec2<T>::Vec2 ()
+{
+ // empty
+}
+
+template <class T>
+inline
+Vec2<T>::Vec2 (T a)
+{
+ x = y = a;
+}
+
+template <class T>
+inline
+Vec2<T>::Vec2 (T a, T b)
+{
+ x = a;
+ y = b;
+}
+
+template <class T>
+inline
+Vec2<T>::Vec2 (const Vec2 &v)
+{
+ x = v.x;
+ y = v.y;
+}
+
+template <class T>
+template <class S>
+inline
+Vec2<T>::Vec2 (const Vec2<S> &v)
+{
+ x = T (v.x);
+ y = T (v.y);
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator = (const Vec2 &v)
+{
+ x = v.x;
+ y = v.y;
+ return *this;
+}
+
+template <class T>
+template <class S>
+inline void
+Vec2<T>::setValue (S a, S b)
+{
+ x = T (a);
+ y = T (b);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec2<T>::setValue (const Vec2<S> &v)
+{
+ x = T (v.x);
+ y = T (v.y);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec2<T>::getValue (S &a, S &b) const
+{
+ a = S (x);
+ b = S (y);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec2<T>::getValue (Vec2<S> &v) const
+{
+ v.x = S (x);
+ v.y = S (y);
+}
+
+template <class T>
+inline T *
+Vec2<T>::getValue()
+{
+ return (T *) &x;
+}
+
+template <class T>
+inline const T *
+Vec2<T>::getValue() const
+{
+ return (const T *) &x;
+}
+
+template <class T>
+template <class S>
+inline bool
+Vec2<T>::operator == (const Vec2<S> &v) const
+{
+ return x == v.x && y == v.y;
+}
+
+template <class T>
+template <class S>
+inline bool
+Vec2<T>::operator != (const Vec2<S> &v) const
+{
+ return x != v.x || y != v.y;
+}
+
+template <class T>
+bool
+Vec2<T>::equalWithAbsError (const Vec2<T> &v, T e) const
+{
+ for (int i = 0; i < 2; i++)
+ if (!Imath::equalWithAbsError ((*this)[i], v[i], e))
+ return false;
+
+ return true;
+}
+
+template <class T>
+bool
+Vec2<T>::equalWithRelError (const Vec2<T> &v, T e) const
+{
+ for (int i = 0; i < 2; i++)
+ if (!Imath::equalWithRelError ((*this)[i], v[i], e))
+ return false;
+
+ return true;
+}
+
+template <class T>
+inline T
+Vec2<T>::dot (const Vec2 &v) const
+{
+ return x * v.x + y * v.y;
+}
+
+template <class T>
+inline T
+Vec2<T>::operator ^ (const Vec2 &v) const
+{
+ return dot (v);
+}
+
+template <class T>
+inline T
+Vec2<T>::cross (const Vec2 &v) const
+{
+ return x * v.y - y * v.x;
+
+}
+
+template <class T>
+inline T
+Vec2<T>::operator % (const Vec2 &v) const
+{
+ return x * v.y - y * v.x;
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator += (const Vec2 &v)
+{
+ x += v.x;
+ y += v.y;
+ return *this;
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator + (const Vec2 &v) const
+{
+ return Vec2 (x + v.x, y + v.y);
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator -= (const Vec2 &v)
+{
+ x -= v.x;
+ y -= v.y;
+ return *this;
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator - (const Vec2 &v) const
+{
+ return Vec2 (x - v.x, y - v.y);
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator - () const
+{
+ return Vec2 (-x, -y);
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::negate ()
+{
+ x = -x;
+ y = -y;
+ return *this;
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator *= (const Vec2 &v)
+{
+ x *= v.x;
+ y *= v.y;
+ return *this;
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator *= (T a)
+{
+ x *= a;
+ y *= a;
+ return *this;
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator * (const Vec2 &v) const
+{
+ return Vec2 (x * v.x, y * v.y);
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator * (T a) const
+{
+ return Vec2 (x * a, y * a);
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator /= (const Vec2 &v)
+{
+ x /= v.x;
+ y /= v.y;
+ return *this;
+}
+
+template <class T>
+inline const Vec2<T> &
+Vec2<T>::operator /= (T a)
+{
+ x /= a;
+ y /= a;
+ return *this;
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator / (const Vec2 &v) const
+{
+ return Vec2 (x / v.x, y / v.y);
+}
+
+template <class T>
+inline Vec2<T>
+Vec2<T>::operator / (T a) const
+{
+ return Vec2 (x / a, y / a);
+}
+
+template <class T>
+inline T
+Vec2<T>::length () const
+{
+ return Math<T>::sqrt (dot (*this));
+}
+
+template <class T>
+inline T
+Vec2<T>::length2 () const
+{
+ return dot (*this);
+}
+
+template <class T>
+const Vec2<T> &
+Vec2<T>::normalize ()
+{
+ T l = length();
+
+ if (l != 0)
+ {
+ x /= l;
+ y /= l;
+ }
+
+ return *this;
+}
+
+template <class T>
+const Vec2<T> &
+Vec2<T>::normalizeExc () throw (Iex::MathExc)
+{
+ T l = length();
+
+ if (l == 0)
+ throw NullVecExc ("Cannot normalize null vector.");
+
+ x /= l;
+ y /= l;
+ return *this;
+}
+
+template <class T>
+inline
+const Vec2<T> &
+Vec2<T>::normalizeNonNull ()
+{
+ T l = length();
+ x /= l;
+ y /= l;
+ return *this;
+}
+
+template <class T>
+Vec2<T>
+Vec2<T>::normalized () const
+{
+ T l = length();
+
+ if (l == 0)
+ return Vec2 (T (0));
+
+ return Vec2 (x / l, y / l);
+}
+
+template <class T>
+Vec2<T>
+Vec2<T>::normalizedExc () const throw (Iex::MathExc)
+{
+ T l = length();
+
+ if (l == 0)
+ throw NullVecExc ("Cannot normalize null vector.");
+
+ return Vec2 (x / l, y / l);
+}
+
+template <class T>
+inline
+Vec2<T>
+Vec2<T>::normalizedNonNull () const
+{
+ T l = length();
+ return Vec2 (x / l, y / l);
+}
+
+
+//-----------------------
+// Implementation of Vec3
+//-----------------------
+
+template <class T>
+inline T &
+Vec3<T>::operator [] (int i)
+{
+ return (&x)[i];
+}
+
+template <class T>
+inline const T &
+Vec3<T>::operator [] (int i) const
+{
+ return (&x)[i];
+}
+
+template <class T>
+inline
+Vec3<T>::Vec3 ()
+{
+ // empty
+}
+
+template <class T>
+inline
+Vec3<T>::Vec3 (T a)
+{
+ x = y = z = a;
+}
+
+template <class T>
+inline
+Vec3<T>::Vec3 (T a, T b, T c)
+{
+ x = a;
+ y = b;
+ z = c;
+}
+
+template <class T>
+inline
+Vec3<T>::Vec3 (const Vec3 &v)
+{
+ x = v.x;
+ y = v.y;
+ z = v.z;
+}
+
+template <class T>
+template <class S>
+inline
+Vec3<T>::Vec3 (const Vec3<S> &v)
+{
+ x = T (v.x);
+ y = T (v.y);
+ z = T (v.z);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator = (const Vec3 &v)
+{
+ x = v.x;
+ y = v.y;
+ z = v.z;
+ return *this;
+}
+
+template <class T>
+template <class S>
+inline void
+Vec3<T>::setValue (S a, S b, S c)
+{
+ x = T (a);
+ y = T (b);
+ z = T (c);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec3<T>::setValue (const Vec3<S> &v)
+{
+ x = T (v.x);
+ y = T (v.y);
+ z = T (v.z);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec3<T>::getValue (S &a, S &b, S &c) const
+{
+ a = S (x);
+ b = S (y);
+ c = S (z);
+}
+
+template <class T>
+template <class S>
+inline void
+Vec3<T>::getValue (Vec3<S> &v) const
+{
+ v.x = S (x);
+ v.y = S (y);
+ v.z = S (z);
+}
+
+template <class T>
+inline T *
+Vec3<T>::getValue()
+{
+ return (T *) &x;
+}
+
+template <class T>
+inline const T *
+Vec3<T>::getValue() const
+{
+ return (const T *) &x;
+}
+
+template <class T>
+template <class S>
+inline bool
+Vec3<T>::operator == (const Vec3<S> &v) const
+{
+ return x == v.x && y == v.y && z == v.z;
+}
+
+template <class T>
+template <class S>
+inline bool
+Vec3<T>::operator != (const Vec3<S> &v) const
+{
+ return x != v.x || y != v.y || z != v.z;
+}
+
+template <class T>
+bool
+Vec3<T>::equalWithAbsError (const Vec3<T> &v, T e) const
+{
+ for (int i = 0; i < 3; i++)
+ if (!Imath::equalWithAbsError ((*this)[i], v[i], e))
+ return false;
+
+ return true;
+}
+
+template <class T>
+bool
+Vec3<T>::equalWithRelError (const Vec3<T> &v, T e) const
+{
+ for (int i = 0; i < 3; i++)
+ if (!Imath::equalWithRelError ((*this)[i], v[i], e))
+ return false;
+
+ return true;
+}
+
+template <class T>
+inline T
+Vec3<T>::dot (const Vec3 &v) const
+{
+ return x * v.x + y * v.y + z * v.z;
+}
+
+template <class T>
+inline T
+Vec3<T>::operator ^ (const Vec3 &v) const
+{
+ return dot (v);
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::cross (const Vec3 &v) const
+{
+ return Vec3 (y * v.z - z * v.y,
+ z * v.x - x * v.z,
+ x * v.y - y * v.x);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator %= (const Vec3 &v)
+{
+ T a = y * v.z - z * v.y;
+ T b = z * v.x - x * v.z;
+ T c = x * v.y - y * v.x;
+ x = a;
+ y = b;
+ z = c;
+ return *this;
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator % (const Vec3 &v) const
+{
+ return Vec3 (y * v.z - z * v.y,
+ z * v.x - x * v.z,
+ x * v.y - y * v.x);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator += (const Vec3 &v)
+{
+ x += v.x;
+ y += v.y;
+ z += v.z;
+ return *this;
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator + (const Vec3 &v) const
+{
+ return Vec3 (x + v.x, y + v.y, z + v.z);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator -= (const Vec3 &v)
+{
+ x -= v.x;
+ y -= v.y;
+ z -= v.z;
+ return *this;
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator - (const Vec3 &v) const
+{
+ return Vec3 (x - v.x, y - v.y, z - v.z);
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator - () const
+{
+ return Vec3 (-x, -y, -z);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::negate ()
+{
+ x = -x;
+ y = -y;
+ z = -z;
+ return *this;
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator *= (const Vec3 &v)
+{
+ x *= v.x;
+ y *= v.y;
+ z *= v.z;
+ return *this;
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator *= (T a)
+{
+ x *= a;
+ y *= a;
+ z *= a;
+ return *this;
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator * (const Vec3 &v) const
+{
+ return Vec3 (x * v.x, y * v.y, z * v.z);
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator * (T a) const
+{
+ return Vec3 (x * a, y * a, z * a);
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator /= (const Vec3 &v)
+{
+ x /= v.x;
+ y /= v.y;
+ z /= v.z;
+ return *this;
+}
+
+template <class T>
+inline const Vec3<T> &
+Vec3<T>::operator /= (T a)
+{
+ x /= a;
+ y /= a;
+ z /= a;
+ return *this;
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator / (const Vec3 &v) const
+{
+ return Vec3 (x / v.x, y / v.y, z / v.z);
+}
+
+template <class T>
+inline Vec3<T>
+Vec3<T>::operator / (T a) const
+{
+ return Vec3 (x / a, y / a, z / a);
+}
+
+
+template <class T>
+inline T
+Vec3<T>::length () const
+{
+ return Math<T>::sqrt (dot (*this));
+}
+
+template <class T>
+inline T
+Vec3<T>::length2 () const
+{
+ return dot (*this);
+}
+
+template <class T>
+const Vec3<T> &
+Vec3<T>::normalize ()
+{
+ T l = length();
+
+ if (l != 0)
+ {
+ x /= l;
+ y /= l;
+ z /= l;
+ }
+
+ return *this;
+}
+
+template <class T>
+const Vec3<T> &
+Vec3<T>::normalizeExc () throw (Iex::MathExc)
+{
+ T l = length();
+
+ if (l == 0)
+ throw NullVecExc ("Cannot normalize null vector.");
+
+ x /= l;
+ y /= l;
+ z /= l;
+ return *this;
+}
+
+template <class T>
+inline
+const Vec3<T> &
+Vec3<T>::normalizeNonNull ()
+{
+ T l = length();
+ x /= l;
+ y /= l;
+ z /= l;
+ return *this;
+}
+
+template <class T>
+Vec3<T>
+Vec3<T>::normalized () const
+{
+ T l = length();
+
+ if (l == 0)
+ return Vec3 (T (0));
+
+ return Vec3 (x / l, y / l, z / l);
+}
+
+template <class T>
+Vec3<T>
+Vec3<T>::normalizedExc () const throw (Iex::MathExc)
+{
+ T l = length();
+
+ if (l == 0)
+ throw NullVecExc ("Cannot normalize null vector.");
+
+ return Vec3 (x / l, y / l, z / l);
+}
+
+template <class T>
+inline
+Vec3<T>
+Vec3<T>::normalizedNonNull () const
+{
+ T l = length();
+ return Vec3 (x / l, y / l, z / l);
+}
+
+
+//-----------------------------
+// Stream output implementation
+//-----------------------------
+
+template <class T>
+std::ostream &
+operator << (std::ostream &s, const Vec2<T> &v)
+{
+ return s << '(' << v.x << ' ' << v.y << ')';
+}
+
+template <class T>
+std::ostream &
+operator << (std::ostream &s, const Vec3<T> &v)
+{
+ return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ')';
+}
+
+
+//-----------------------------------------
+// Implementation of reverse multiplication
+//-----------------------------------------
+
+template <class T>
+inline Vec2<T>
+operator * (T a, const Vec2<T> &v)
+{
+ return Vec2<T> (a * v.x, a * v.y);
+}
+
+template <class T>
+inline Vec3<T>
+operator * (T a, const Vec3<T> &v)
+{
+ return Vec3<T> (a * v.x, a * v.y, a * v.z);
+}
+
+
+#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
+#pragma warning(default:4290)
+#endif
+
+} // namespace Imath
+
+#endif
projects / opencv / blobdiff