D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
usr
/
include
/
OpenEXR
/
Filename :
ImathShear.h
back
Copy
/////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2004-2012, 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 "ImathNamespace.h" #include <iostream> IMATH_INTERNAL_NAMESPACE_HEADER_ENTER 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_INTERNAL_NAMESPACE::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_INTERNAL_NAMESPACE::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); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHSHEAR_H