1/////////////////////////////////////////////////////////////////////////// 2// 3// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas 4// Digital Ltd. LLC 5// 6// All rights reserved. 7// 8// Redistribution and use in source and binary forms, with or without 9// modification, are permitted provided that the following conditions are 10// met: 11// * Redistributions of source code must retain the above copyright 12// notice, this list of conditions and the following disclaimer. 13// * Redistributions in binary form must reproduce the above 14// copyright notice, this list of conditions and the following disclaimer 15// in the documentation and/or other materials provided with the 16// distribution. 17// * Neither the name of Industrial Light & Magic nor the names of 18// its contributors may be used to endorse or promote products derived 19// from this software without specific prior written permission. 20// 21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32// 33/////////////////////////////////////////////////////////////////////////// 34 35 36 37#ifndef INCLUDED_IMATHSHEAR_H 38#define INCLUDED_IMATHSHEAR_H 39 40//---------------------------------------------------- 41// 42// Shear6 class template. 43// 44//---------------------------------------------------- 45 46#include "ImathExc.h" 47#include "ImathLimits.h" 48#include "ImathMath.h" 49#include "ImathVec.h" 50 51#include <iostream> 52 53 54namespace Imath { 55 56 57 58 59template <class T> class Shear6 60{ 61 public: 62 63 //------------------- 64 // Access to elements 65 //------------------- 66 67 T xy, xz, yz, yx, zx, zy; 68 69 T & operator [] (int i); 70 const T & operator [] (int i) const; 71 72 73 //------------- 74 // Constructors 75 //------------- 76 77 Shear6 (); // (0 0 0 0 0 0) 78 Shear6 (T XY, T XZ, T YZ); // (XY XZ YZ 0 0 0) 79 Shear6 (const Vec3<T> &v); // (v.x v.y v.z 0 0 0) 80 template <class S> // (v.x v.y v.z 0 0 0) 81 Shear6 (const Vec3<S> &v); 82 Shear6 (T XY, T XZ, T YZ, // (XY XZ YZ YX ZX ZY) 83 T YX, T ZX, T ZY); 84 85 86 //--------------------------------- 87 // Copy constructors and assignment 88 //--------------------------------- 89 90 Shear6 (const Shear6 &h); 91 template <class S> Shear6 (const Shear6<S> &h); 92 93 const Shear6 & operator = (const Shear6 &h); 94 template <class S> 95 const Shear6 & operator = (const Vec3<S> &v); 96 97 98 //---------------------- 99 // Compatibility with Sb 100 //---------------------- 101 102 template <class S> 103 void setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY); 104 105 template <class S> 106 void setValue (const Shear6<S> &h); 107 108 template <class S> 109 void getValue (S &XY, S &XZ, S &YZ, 110 S &YX, S &ZX, S &ZY) const; 111 112 template <class S> 113 void getValue (Shear6<S> &h) const; 114 115 T * getValue(); 116 const T * getValue() const; 117 118 119 //--------- 120 // Equality 121 //--------- 122 123 template <class S> 124 bool operator == (const Shear6<S> &h) const; 125 126 template <class S> 127 bool operator != (const Shear6<S> &h) const; 128 129 //----------------------------------------------------------------------- 130 // Compare two shears and test if they are "approximately equal": 131 // 132 // equalWithAbsError (h, e) 133 // 134 // Returns true if the coefficients of this and h are the same with 135 // an absolute error of no more than e, i.e., for all i 136 // 137 // abs (this[i] - h[i]) <= e 138 // 139 // equalWithRelError (h, e) 140 // 141 // Returns true if the coefficients of this and h are the same with 142 // a relative error of no more than e, i.e., for all i 143 // 144 // abs (this[i] - h[i]) <= e * abs (this[i]) 145 //----------------------------------------------------------------------- 146 147 bool equalWithAbsError (const Shear6<T> &h, T e) const; 148 bool equalWithRelError (const Shear6<T> &h, T e) const; 149 150 151 //------------------------ 152 // Component-wise addition 153 //------------------------ 154 155 const Shear6 & operator += (const Shear6 &h); 156 Shear6 operator + (const Shear6 &h) const; 157 158 159 //--------------------------- 160 // Component-wise subtraction 161 //--------------------------- 162 163 const Shear6 & operator -= (const Shear6 &h); 164 Shear6 operator - (const Shear6 &h) const; 165 166 167 //------------------------------------ 168 // Component-wise multiplication by -1 169 //------------------------------------ 170 171 Shear6 operator - () const; 172 const Shear6 & negate (); 173 174 175 //------------------------------ 176 // Component-wise multiplication 177 //------------------------------ 178 179 const Shear6 & operator *= (const Shear6 &h); 180 const Shear6 & operator *= (T a); 181 Shear6 operator * (const Shear6 &h) const; 182 Shear6 operator * (T a) const; 183 184 185 //------------------------ 186 // Component-wise division 187 //------------------------ 188 189 const Shear6 & operator /= (const Shear6 &h); 190 const Shear6 & operator /= (T a); 191 Shear6 operator / (const Shear6 &h) const; 192 Shear6 operator / (T a) const; 193 194 195 //---------------------------------------------------------- 196 // Number of dimensions, i.e. number of elements in a Shear6 197 //---------------------------------------------------------- 198 199 static unsigned int dimensions() {return 6;} 200 201 202 //------------------------------------------------- 203 // Limitations of type T (see also class limits<T>) 204 //------------------------------------------------- 205 206 static T baseTypeMin() {return limits<T>::min();} 207 static T baseTypeMax() {return limits<T>::max();} 208 static T baseTypeSmallest() {return limits<T>::smallest();} 209 static T baseTypeEpsilon() {return limits<T>::epsilon();} 210 211 212 //-------------------------------------------------------------- 213 // Base type -- in templates, which accept a parameter, V, which 214 // could be either a Vec2<T> or a Shear6<T>, you can refer to T as 215 // V::BaseType 216 //-------------------------------------------------------------- 217 218 typedef T BaseType; 219}; 220 221 222//-------------- 223// Stream output 224//-------------- 225 226template <class T> 227std::ostream & operator << (std::ostream &s, const Shear6<T> &h); 228 229 230//---------------------------------------------------- 231// Reverse multiplication: scalar * Shear6<T> 232//---------------------------------------------------- 233 234template <class S, class T> Shear6<T> operator * (S a, const Shear6<T> &h); 235 236 237//------------------------- 238// Typedefs for convenience 239//------------------------- 240 241typedef Vec3 <float> Shear3f; 242typedef Vec3 <double> Shear3d; 243typedef Shear6 <float> Shear6f; 244typedef Shear6 <double> Shear6d; 245 246 247 248 249//----------------------- 250// Implementation of Shear6 251//----------------------- 252 253template <class T> 254inline T & 255Shear6<T>::operator [] (int i) 256{ 257 return (&xy)[i]; 258} 259 260template <class T> 261inline const T & 262Shear6<T>::operator [] (int i) const 263{ 264 return (&xy)[i]; 265} 266 267template <class T> 268inline 269Shear6<T>::Shear6 () 270{ 271 xy = xz = yz = yx = zx = zy = 0; 272} 273 274template <class T> 275inline 276Shear6<T>::Shear6 (T XY, T XZ, T YZ) 277{ 278 xy = XY; 279 xz = XZ; 280 yz = YZ; 281 yx = 0; 282 zx = 0; 283 zy = 0; 284} 285 286template <class T> 287inline 288Shear6<T>::Shear6 (const Vec3<T> &v) 289{ 290 xy = v.x; 291 xz = v.y; 292 yz = v.z; 293 yx = 0; 294 zx = 0; 295 zy = 0; 296} 297 298template <class T> 299template <class S> 300inline 301Shear6<T>::Shear6 (const Vec3<S> &v) 302{ 303 xy = T (v.x); 304 xz = T (v.y); 305 yz = T (v.z); 306 yx = 0; 307 zx = 0; 308 zy = 0; 309} 310 311template <class T> 312inline 313Shear6<T>::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY) 314{ 315 xy = XY; 316 xz = XZ; 317 yz = YZ; 318 yx = YX; 319 zx = ZX; 320 zy = ZY; 321} 322 323template <class T> 324inline 325Shear6<T>::Shear6 (const Shear6 &h) 326{ 327 xy = h.xy; 328 xz = h.xz; 329 yz = h.yz; 330 yx = h.yx; 331 zx = h.zx; 332 zy = h.zy; 333} 334 335template <class T> 336template <class S> 337inline 338Shear6<T>::Shear6 (const Shear6<S> &h) 339{ 340 xy = T (h.xy); 341 xz = T (h.xz); 342 yz = T (h.yz); 343 yx = T (h.yx); 344 zx = T (h.zx); 345 zy = T (h.zy); 346} 347 348template <class T> 349inline const Shear6<T> & 350Shear6<T>::operator = (const Shear6 &h) 351{ 352 xy = h.xy; 353 xz = h.xz; 354 yz = h.yz; 355 yx = h.yx; 356 zx = h.zx; 357 zy = h.zy; 358 return *this; 359} 360 361template <class T> 362template <class S> 363inline const Shear6<T> & 364Shear6<T>::operator = (const Vec3<S> &v) 365{ 366 xy = T (v.x); 367 xz = T (v.y); 368 yz = T (v.z); 369 yx = 0; 370 zx = 0; 371 zy = 0; 372 return *this; 373} 374 375template <class T> 376template <class S> 377inline void 378Shear6<T>::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY) 379{ 380 xy = T (XY); 381 xz = T (XZ); 382 yz = T (YZ); 383 yx = T (YX); 384 zx = T (ZX); 385 zy = T (ZY); 386} 387 388template <class T> 389template <class S> 390inline void 391Shear6<T>::setValue (const Shear6<S> &h) 392{ 393 xy = T (h.xy); 394 xz = T (h.xz); 395 yz = T (h.yz); 396 yx = T (h.yx); 397 zx = T (h.zx); 398 zy = T (h.zy); 399} 400 401template <class T> 402template <class S> 403inline void 404Shear6<T>::getValue (S &XY, S &XZ, S &YZ, S &YX, S &ZX, S &ZY) const 405{ 406 XY = S (xy); 407 XZ = S (xz); 408 YZ = S (yz); 409 YX = S (yx); 410 ZX = S (zx); 411 ZY = S (zy); 412} 413 414template <class T> 415template <class S> 416inline void 417Shear6<T>::getValue (Shear6<S> &h) const 418{ 419 h.xy = S (xy); 420 h.xz = S (xz); 421 h.yz = S (yz); 422 h.yx = S (yx); 423 h.zx = S (zx); 424 h.zy = S (zy); 425} 426 427template <class T> 428inline T * 429Shear6<T>::getValue() 430{ 431 return (T *) &xy; 432} 433 434template <class T> 435inline const T * 436Shear6<T>::getValue() const 437{ 438 return (const T *) &xy; 439} 440 441template <class T> 442template <class S> 443inline bool 444Shear6<T>::operator == (const Shear6<S> &h) const 445{ 446 return xy == h.xy && xz == h.xz && yz == h.yz && 447 yx == h.yx && zx == h.zx && zy == h.zy; 448} 449 450template <class T> 451template <class S> 452inline bool 453Shear6<T>::operator != (const Shear6<S> &h) const 454{ 455 return xy != h.xy || xz != h.xz || yz != h.yz || 456 yx != h.yx || zx != h.zx || zy != h.zy; 457} 458 459template <class T> 460bool 461Shear6<T>::equalWithAbsError (const Shear6<T> &h, T e) const 462{ 463 for (int i = 0; i < 6; i++) 464 if (!Imath::equalWithAbsError ((*this)[i], h[i], e)) 465 return false; 466 467 return true; 468} 469 470template <class T> 471bool 472Shear6<T>::equalWithRelError (const Shear6<T> &h, T e) const 473{ 474 for (int i = 0; i < 6; i++) 475 if (!Imath::equalWithRelError ((*this)[i], h[i], e)) 476 return false; 477 478 return true; 479} 480 481 482template <class T> 483inline const Shear6<T> & 484Shear6<T>::operator += (const Shear6 &h) 485{ 486 xy += h.xy; 487 xz += h.xz; 488 yz += h.yz; 489 yx += h.yx; 490 zx += h.zx; 491 zy += h.zy; 492 return *this; 493} 494 495template <class T> 496inline Shear6<T> 497Shear6<T>::operator + (const Shear6 &h) const 498{ 499 return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz, 500 yx + h.yx, zx + h.zx, zy + h.zy); 501} 502 503template <class T> 504inline const Shear6<T> & 505Shear6<T>::operator -= (const Shear6 &h) 506{ 507 xy -= h.xy; 508 xz -= h.xz; 509 yz -= h.yz; 510 yx -= h.yx; 511 zx -= h.zx; 512 zy -= h.zy; 513 return *this; 514} 515 516template <class T> 517inline Shear6<T> 518Shear6<T>::operator - (const Shear6 &h) const 519{ 520 return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz, 521 yx - h.yx, zx - h.zx, zy - h.zy); 522} 523 524template <class T> 525inline Shear6<T> 526Shear6<T>::operator - () const 527{ 528 return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy); 529} 530 531template <class T> 532inline const Shear6<T> & 533Shear6<T>::negate () 534{ 535 xy = -xy; 536 xz = -xz; 537 yz = -yz; 538 yx = -yx; 539 zx = -zx; 540 zy = -zy; 541 return *this; 542} 543 544template <class T> 545inline const Shear6<T> & 546Shear6<T>::operator *= (const Shear6 &h) 547{ 548 xy *= h.xy; 549 xz *= h.xz; 550 yz *= h.yz; 551 yx *= h.yx; 552 zx *= h.zx; 553 zy *= h.zy; 554 return *this; 555} 556 557template <class T> 558inline const Shear6<T> & 559Shear6<T>::operator *= (T a) 560{ 561 xy *= a; 562 xz *= a; 563 yz *= a; 564 yx *= a; 565 zx *= a; 566 zy *= a; 567 return *this; 568} 569 570template <class T> 571inline Shear6<T> 572Shear6<T>::operator * (const Shear6 &h) const 573{ 574 return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz, 575 yx * h.yx, zx * h.zx, zy * h.zy); 576} 577 578template <class T> 579inline Shear6<T> 580Shear6<T>::operator * (T a) const 581{ 582 return Shear6 (xy * a, xz * a, yz * a, 583 yx * a, zx * a, zy * a); 584} 585 586template <class T> 587inline const Shear6<T> & 588Shear6<T>::operator /= (const Shear6 &h) 589{ 590 xy /= h.xy; 591 xz /= h.xz; 592 yz /= h.yz; 593 yx /= h.yx; 594 zx /= h.zx; 595 zy /= h.zy; 596 return *this; 597} 598 599template <class T> 600inline const Shear6<T> & 601Shear6<T>::operator /= (T a) 602{ 603 xy /= a; 604 xz /= a; 605 yz /= a; 606 yx /= a; 607 zx /= a; 608 zy /= a; 609 return *this; 610} 611 612template <class T> 613inline Shear6<T> 614Shear6<T>::operator / (const Shear6 &h) const 615{ 616 return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz, 617 yx / h.yx, zx / h.zx, zy / h.zy); 618} 619 620template <class T> 621inline Shear6<T> 622Shear6<T>::operator / (T a) const 623{ 624 return Shear6 (xy / a, xz / a, yz / a, 625 yx / a, zx / a, zy / a); 626} 627 628 629//----------------------------- 630// Stream output implementation 631//----------------------------- 632 633template <class T> 634std::ostream & 635operator << (std::ostream &s, const Shear6<T> &h) 636{ 637 return s << '(' 638 << h.xy << ' ' << h.xz << ' ' << h.yz 639 << h.yx << ' ' << h.zx << ' ' << h.zy 640 << ')'; 641} 642 643 644//----------------------------------------- 645// Implementation of reverse multiplication 646//----------------------------------------- 647 648template <class S, class T> 649inline Shear6<T> 650operator * (S a, const Shear6<T> &h) 651{ 652 return Shear6<T> (a * h.xy, a * h.xz, a * h.yz, 653 a * h.yx, a * h.zx, a * h.zy); 654} 655 656 657} // namespace Imath 658 659#endif 660