--- /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_IMATHSHEAR_H
+#define INCLUDED_IMATHSHEAR_H
+
+//----------------------------------------------------
+//
+// Shear6 class template.
+//
+//----------------------------------------------------
+
+#include "ImathExc.h"
+#include "ImathLimits.h"
+#include "ImathMath.h"
+#include "ImathVec.h"
+
+#include <iostream>
+
+
+namespace Imath {
+
+
+
+
+template <class T> class Shear6
+{
+ public:
+
+ //-------------------
+ // Access to elements
+ //-------------------
+
+ T xy, xz, yz, yx, zx, zy;
+
+ T & operator [] (int i);
+ const T & operator [] (int i) const;
+
+
+ //-------------
+ // Constructors
+ //-------------
+
+ Shear6 (); // (0 0 0 0 0 0)
+ Shear6 (T XY, T XZ, T YZ); // (XY XZ YZ 0 0 0)
+ Shear6 (const Vec3<T> &v); // (v.x v.y v.z 0 0 0)
+ template <class S> // (v.x v.y v.z 0 0 0)
+ Shear6 (const Vec3<S> &v);
+ Shear6 (T XY, T XZ, T YZ, // (XY XZ YZ YX ZX ZY)
+ T YX, T ZX, T ZY);
+
+
+ //---------------------------------
+ // Copy constructors and assignment
+ //---------------------------------
+
+ Shear6 (const Shear6 &h);
+ template <class S> Shear6 (const Shear6<S> &h);
+
+ const Shear6 & operator = (const Shear6 &h);
+ template <class S>
+ const Shear6 & operator = (const Vec3<S> &v);
+
+
+ //----------------------
+ // Compatibility with Sb
+ //----------------------
+
+ template <class S>
+ void setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY);
+
+ template <class S>
+ void setValue (const Shear6<S> &h);
+
+ template <class S>
+ void getValue (S &XY, S &XZ, S &YZ,
+ S &YX, S &ZX, S &ZY) const;
+
+ template <class S>
+ void getValue (Shear6<S> &h) const;
+
+ T * getValue();
+ const T * getValue() const;
+
+
+ //---------
+ // Equality
+ //---------
+
+ template <class S>
+ bool operator == (const Shear6<S> &h) const;
+
+ template <class S>
+ bool operator != (const Shear6<S> &h) const;
+
+ //-----------------------------------------------------------------------
+ // Compare two shears and test if they are "approximately equal":
+ //
+ // equalWithAbsError (h, e)
+ //
+ // Returns true if the coefficients of this and h are the same with
+ // an absolute error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - h[i]) <= e
+ //
+ // equalWithRelError (h, e)
+ //
+ // Returns true if the coefficients of this and h are the same with
+ // a relative error of no more than e, i.e., for all i
+ //
+ // abs (this[i] - h[i]) <= e * abs (this[i])
+ //-----------------------------------------------------------------------
+
+ bool equalWithAbsError (const Shear6<T> &h, T e) const;
+ bool equalWithRelError (const Shear6<T> &h, T e) const;
+
+
+ //------------------------
+ // Component-wise addition
+ //------------------------
+
+ const Shear6 & operator += (const Shear6 &h);
+ Shear6 operator + (const Shear6 &h) const;
+
+
+ //---------------------------
+ // Component-wise subtraction
+ //---------------------------
+
+ const Shear6 & operator -= (const Shear6 &h);
+ Shear6 operator - (const Shear6 &h) const;
+
+
+ //------------------------------------
+ // Component-wise multiplication by -1
+ //------------------------------------
+
+ Shear6 operator - () const;
+ const Shear6 & negate ();
+
+
+ //------------------------------
+ // Component-wise multiplication
+ //------------------------------
+
+ const Shear6 & operator *= (const Shear6 &h);
+ const Shear6 & operator *= (T a);
+ Shear6 operator * (const Shear6 &h) const;
+ Shear6 operator * (T a) const;
+
+
+ //------------------------
+ // Component-wise division
+ //------------------------
+
+ const Shear6 & operator /= (const Shear6 &h);
+ const Shear6 & operator /= (T a);
+ Shear6 operator / (const Shear6 &h) const;
+ Shear6 operator / (T a) const;
+
+
+ //----------------------------------------------------------
+ // Number of dimensions, i.e. number of elements in a Shear6
+ //----------------------------------------------------------
+
+ static unsigned int dimensions() {return 6;}
+
+
+ //-------------------------------------------------
+ // 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 Shear6<T>, you can refer to T as
+ // V::BaseType
+ //--------------------------------------------------------------
+
+ typedef T BaseType;
+};
+
+
+//--------------
+// Stream output
+//--------------
+
+template <class T>
+std::ostream & operator << (std::ostream &s, const Shear6<T> &h);
+
+
+//----------------------------------------------------
+// Reverse multiplication: scalar * Shear6<T>
+//----------------------------------------------------
+
+template <class S, class T> Shear6<T> operator * (S a, const Shear6<T> &h);
+
+
+//-------------------------
+// Typedefs for convenience
+//-------------------------
+
+typedef Vec3 <float> Shear3f;
+typedef Vec3 <double> Shear3d;
+typedef Shear6 <float> Shear6f;
+typedef Shear6 <double> Shear6d;
+
+
+
+
+//-----------------------
+// Implementation of Shear6
+//-----------------------
+
+template <class T>
+inline T &
+Shear6<T>::operator [] (int i)
+{
+ return (&xy)[i];
+}
+
+template <class T>
+inline const T &
+Shear6<T>::operator [] (int i) const
+{
+ return (&xy)[i];
+}
+
+template <class T>
+inline
+Shear6<T>::Shear6 ()
+{
+ xy = xz = yz = yx = zx = zy = 0;
+}
+
+template <class T>
+inline
+Shear6<T>::Shear6 (T XY, T XZ, T YZ)
+{
+ xy = XY;
+ xz = XZ;
+ yz = YZ;
+ yx = 0;
+ zx = 0;
+ zy = 0;
+}
+
+template <class T>
+inline
+Shear6<T>::Shear6 (const Vec3<T> &v)
+{
+ xy = v.x;
+ xz = v.y;
+ yz = v.z;
+ yx = 0;
+ zx = 0;
+ zy = 0;
+}
+
+template <class T>
+template <class S>
+inline
+Shear6<T>::Shear6 (const Vec3<S> &v)
+{
+ xy = T (v.x);
+ xz = T (v.y);
+ yz = T (v.z);
+ yx = 0;
+ zx = 0;
+ zy = 0;
+}
+
+template <class T>
+inline
+Shear6<T>::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY)
+{
+ xy = XY;
+ xz = XZ;
+ yz = YZ;
+ yx = YX;
+ zx = ZX;
+ zy = ZY;
+}
+
+template <class T>
+inline
+Shear6<T>::Shear6 (const Shear6 &h)
+{
+ xy = h.xy;
+ xz = h.xz;
+ yz = h.yz;
+ yx = h.yx;
+ zx = h.zx;
+ zy = h.zy;
+}
+
+template <class T>
+template <class S>
+inline
+Shear6<T>::Shear6 (const Shear6<S> &h)
+{
+ xy = T (h.xy);
+ xz = T (h.xz);
+ yz = T (h.yz);
+ yx = T (h.yx);
+ zx = T (h.zx);
+ zy = T (h.zy);
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator = (const Shear6 &h)
+{
+ xy = h.xy;
+ xz = h.xz;
+ yz = h.yz;
+ yx = h.yx;
+ zx = h.zx;
+ zy = h.zy;
+ return *this;
+}
+
+template <class T>
+template <class S>
+inline const Shear6<T> &
+Shear6<T>::operator = (const Vec3<S> &v)
+{
+ xy = T (v.x);
+ xz = T (v.y);
+ yz = T (v.z);
+ yx = 0;
+ zx = 0;
+ zy = 0;
+ return *this;
+}
+
+template <class T>
+template <class S>
+inline void
+Shear6<T>::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY)
+{
+ xy = T (XY);
+ xz = T (XZ);
+ yz = T (YZ);
+ yx = T (YX);
+ zx = T (ZX);
+ zy = T (ZY);
+}
+
+template <class T>
+template <class S>
+inline void
+Shear6<T>::setValue (const Shear6<S> &h)
+{
+ xy = T (h.xy);
+ xz = T (h.xz);
+ yz = T (h.yz);
+ yx = T (h.yx);
+ zx = T (h.zx);
+ zy = T (h.zy);
+}
+
+template <class T>
+template <class S>
+inline void
+Shear6<T>::getValue (S &XY, S &XZ, S &YZ, S &YX, S &ZX, S &ZY) const
+{
+ XY = S (xy);
+ XZ = S (xz);
+ YZ = S (yz);
+ YX = S (yx);
+ ZX = S (zx);
+ ZY = S (zy);
+}
+
+template <class T>
+template <class S>
+inline void
+Shear6<T>::getValue (Shear6<S> &h) const
+{
+ h.xy = S (xy);
+ h.xz = S (xz);
+ h.yz = S (yz);
+ h.yx = S (yx);
+ h.zx = S (zx);
+ h.zy = S (zy);
+}
+
+template <class T>
+inline T *
+Shear6<T>::getValue()
+{
+ return (T *) &xy;
+}
+
+template <class T>
+inline const T *
+Shear6<T>::getValue() const
+{
+ return (const T *) &xy;
+}
+
+template <class T>
+template <class S>
+inline bool
+Shear6<T>::operator == (const Shear6<S> &h) const
+{
+ return xy == h.xy && xz == h.xz && yz == h.yz &&
+ yx == h.yx && zx == h.zx && zy == h.zy;
+}
+
+template <class T>
+template <class S>
+inline bool
+Shear6<T>::operator != (const Shear6<S> &h) const
+{
+ return xy != h.xy || xz != h.xz || yz != h.yz ||
+ yx != h.yx || zx != h.zx || zy != h.zy;
+}
+
+template <class T>
+bool
+Shear6<T>::equalWithAbsError (const Shear6<T> &h, T e) const
+{
+ for (int i = 0; i < 6; i++)
+ if (!Imath::equalWithAbsError ((*this)[i], h[i], e))
+ return false;
+
+ return true;
+}
+
+template <class T>
+bool
+Shear6<T>::equalWithRelError (const Shear6<T> &h, T e) const
+{
+ for (int i = 0; i < 6; i++)
+ if (!Imath::equalWithRelError ((*this)[i], h[i], e))
+ return false;
+
+ return true;
+}
+
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator += (const Shear6 &h)
+{
+ xy += h.xy;
+ xz += h.xz;
+ yz += h.yz;
+ yx += h.yx;
+ zx += h.zx;
+ zy += h.zy;
+ return *this;
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator + (const Shear6 &h) const
+{
+ return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz,
+ yx + h.yx, zx + h.zx, zy + h.zy);
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator -= (const Shear6 &h)
+{
+ xy -= h.xy;
+ xz -= h.xz;
+ yz -= h.yz;
+ yx -= h.yx;
+ zx -= h.zx;
+ zy -= h.zy;
+ return *this;
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator - (const Shear6 &h) const
+{
+ return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz,
+ yx - h.yx, zx - h.zx, zy - h.zy);
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator - () const
+{
+ return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy);
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::negate ()
+{
+ xy = -xy;
+ xz = -xz;
+ yz = -yz;
+ yx = -yx;
+ zx = -zx;
+ zy = -zy;
+ return *this;
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator *= (const Shear6 &h)
+{
+ xy *= h.xy;
+ xz *= h.xz;
+ yz *= h.yz;
+ yx *= h.yx;
+ zx *= h.zx;
+ zy *= h.zy;
+ return *this;
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator *= (T a)
+{
+ xy *= a;
+ xz *= a;
+ yz *= a;
+ yx *= a;
+ zx *= a;
+ zy *= a;
+ return *this;
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator * (const Shear6 &h) const
+{
+ return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz,
+ yx * h.yx, zx * h.zx, zy * h.zy);
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator * (T a) const
+{
+ return Shear6 (xy * a, xz * a, yz * a,
+ yx * a, zx * a, zy * a);
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator /= (const Shear6 &h)
+{
+ xy /= h.xy;
+ xz /= h.xz;
+ yz /= h.yz;
+ yx /= h.yx;
+ zx /= h.zx;
+ zy /= h.zy;
+ return *this;
+}
+
+template <class T>
+inline const Shear6<T> &
+Shear6<T>::operator /= (T a)
+{
+ xy /= a;
+ xz /= a;
+ yz /= a;
+ yx /= a;
+ zx /= a;
+ zy /= a;
+ return *this;
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator / (const Shear6 &h) const
+{
+ return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz,
+ yx / h.yx, zx / h.zx, zy / h.zy);
+}
+
+template <class T>
+inline Shear6<T>
+Shear6<T>::operator / (T a) const
+{
+ return Shear6 (xy / a, xz / a, yz / a,
+ yx / a, zx / a, zy / a);
+}
+
+
+//-----------------------------
+// Stream output implementation
+//-----------------------------
+
+template <class T>
+std::ostream &
+operator << (std::ostream &s, const Shear6<T> &h)
+{
+ return s << '('
+ << h.xy << ' ' << h.xz << ' ' << h.yz
+ << h.yx << ' ' << h.zx << ' ' << h.zy
+ << ')';
+}
+
+
+//-----------------------------------------
+// Implementation of reverse multiplication
+//-----------------------------------------
+
+template <class S, class T>
+inline Shear6<T>
+operator * (S a, const Shear6<T> &h)
+{
+ return Shear6<T> (a * h.xy, a * h.xz, a * h.yz,
+ a * h.yx, a * h.zx, a * h.zy);
+}
+
+
+} // namespace Imath
+
+#endif
projects / opencv / blobdiff