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