Horus Doc || C++ Reference || Class Overview   Pixels   Images   Detector   Geometry   Registry || Doxygen's quick Index  

HxVec3Int.h

00001 /*
00002  *  Copyright (c) 1998, University of Amsterdam, The Netherlands.
00003  *  All rights reserved.
00004  *
00005  *
00006  *  Author(s):
00007  *  Dennis Koelma (koelma@wins.uva.nl)
00008  *  Edo Poll (poll@wins.uva.nl)
00009  */
00010 
00011 #ifndef HxVec3Int_h
00012 #define HxVec3Int_h
00013 
00014 #include <cstdlib>
00015 #include "HxIoFwd.h"
00016 #include "HxMath.h"
00017 #include "HxString.h"
00018 
00019 #undef min
00020 #undef max
00021 
00022 #include "HxScalarInt.h"
00023 class HxScalarDouble;
00024 class HxVec2Int;
00025 class HxVec2Double;
00026 class HxVec3Double;
00027 class HxComplex;
00028 
00029 
00033 class L_HXBASIS HxVec3Int {
00034 public:
00035 
00037 
00039                             HxVec3Int();
00040 
00042                             HxVec3Int(int x, int y, int z);
00043                             
00045                             HxVec3Int(const HxVec3Int& v);
00047 
00048     void*                   operator new(size_t, void * = 0);
00049 
00051 
00054     int                     dim() const;
00055     
00057     int                     x() const;
00058     
00060     int                     y() const;
00061     
00063     int                     z() const;
00064 
00066     int                     getValue(int dimension) const; // dimension: 1, 2 or 3
00067     void                    setValue(int dimension, int value); // dimension: 1, 2 or 3
00069 
00071 /** \name Conversion*/
00073                             operator HxScalarInt() const;
00074 
00076                             operator HxScalarDouble() const;
00077 
00079                             operator HxVec2Int() const;
00080 
00082                             operator HxVec2Double() const;
00083 
00085                             operator HxVec3Double() const;
00086 
00088                             operator HxComplex() const;
00090 
00092 
00096     int                     operator==(const HxVec3Int& v) const;
00097 
00099     int                     operator!=(const HxVec3Int& v) const;
00100 
00102     int                     operator< (const HxVec3Int& v) const;
00103 
00105     int                     operator<=(const HxVec3Int& v) const;
00106 
00108     int                     operator> (const HxVec3Int& v) const;
00109 
00111     int                     operator>=(const HxVec3Int& v) const;
00112 
00117     static const HxVec3Int SMALL_VAL;
00118 
00123     static const HxVec3Int LARGE_VAL;
00125 
00127 
00131     HxVec3Int               operator-() const;
00132 
00134     HxVec3Int               complement() const;
00135 
00137     HxVec3Int               abs() const;
00138 
00140     HxVec3Int               ceil() const;
00141 
00143     HxVec3Int               floor() const;
00144 
00146     HxVec3Int               round() const;
00147 
00149     HxScalarInt             sum() const;
00150     
00152     HxScalarInt             product() const;
00153 
00155     HxScalarInt             min() const;
00156 
00158     HxScalarInt             max() const;
00159 
00161     HxScalarInt             norm1() const;
00162 
00164     HxScalarDouble          norm2() const;
00165 
00167     HxScalarInt             normInf() const;
00168 
00170     HxVec3Double            sqrt() const;
00171 
00173     HxVec3Double            sin() const;
00174 
00176     HxVec3Double            cos() const;
00177 
00179     HxVec3Double            tan() const;
00180 
00182     HxVec3Double            asin() const;
00183 
00185     HxVec3Double            acos() const;
00186 
00188     HxVec3Double            atan() const;
00189 
00191     HxScalarDouble          atan2() const;
00192 
00194     HxVec3Double            sinh() const;
00195 
00197     HxVec3Double            cosh() const;
00198 
00200     HxVec3Double            tanh() const;
00201 
00203     HxVec3Double            exp() const;
00204 
00206     HxVec3Double            log() const;
00207 
00209     HxVec3Double            log10() const;
00211 
00213 
00217     HxVec3Int&              operator+=(const HxVec3Int& v);
00218 
00220     HxVec3Int&              operator-=(const HxVec3Int& v);
00221 
00223     HxVec3Int&              operator*=(const HxVec3Int& v);
00224 
00226     HxVec3Int&              operator/=(const HxVec3Int& v);
00227 
00228 
00230     friend HxVec3Int        operator+(const HxVec3Int& v1,
00231                                       const HxVec3Int& v2);
00232 
00234     friend HxVec3Int        operator-(const HxVec3Int& v1,
00235                                       const HxVec3Int& v2);
00236 
00238     friend HxVec3Int        operator*(const HxVec3Int& v1,
00239                                       const HxVec3Int& v2);
00240 
00242     friend HxVec3Int        operator/(const HxVec3Int& v1,
00243                                       const HxVec3Int& v2);
00244 
00245 
00247     HxVec3Int               min(const HxVec3Int& v) const;
00248 
00250     HxVec3Int&              minAssign(const HxVec3Int& v);
00251 
00253     HxVec3Int               max(const HxVec3Int& v) const;
00254 
00256     HxVec3Int&              maxAssign(const HxVec3Int& v);
00257 
00259     HxVec3Int               inf(const HxVec3Int& v) const;
00260 
00262     HxVec3Int&              infAssign(const HxVec3Int& v);
00263 
00265     HxVec3Int               sup(const HxVec3Int& v) const;
00266 
00268     HxVec3Int&              supAssign(const HxVec3Int& v);
00269 
00271     HxVec3Int               pow(const HxVec3Int& v) const;
00272 
00274     HxVec3Int               mod(const HxVec3Int& v) const;
00275 
00277     HxVec3Int               and(const HxVec3Int& v) const;
00278 
00280     HxVec3Int               or(const HxVec3Int& v) const;
00281 
00283     HxVec3Int               xor(const HxVec3Int& v) const;
00284 
00286     HxVec3Int               leftShift(const HxVec3Int& v) const;
00287 
00289     HxVec3Int               rightShift(const HxVec3Int& v) const;
00290 
00292     HxScalarInt             dot(const HxVec3Int& v) const;
00293 
00295     HxVec3Int               cross(const HxVec3Int& v) const;
00297 
00299 
00301     STD_OSTREAM&            put(STD_OSTREAM& os) const;
00302 
00304     HxString                toString() const;
00306 
00307 private:
00308     int                     _values[3];
00309 };
00310 
00311 typedef HxVec3Int (*HxUpoVec3Int)(const HxVec3Int& a);
00312 typedef HxVec3Int (*HxBpoVec3Int)(const HxVec3Int& a1, const HxVec3Int& a2);
00313 
00314 inline STD_OSTREAM&
00315 operator<<(STD_OSTREAM& os, const HxVec3Int v)
00316 {
00317     return v.put(os);
00318 }
00319 
00320 inline
00321 HxVec3Int::HxVec3Int() 
00322 { 
00323 }
00324 
00325 inline
00326 HxVec3Int::HxVec3Int(int x, int y, int z)
00327 {
00328     _values[0] = x;
00329     _values[1] = y;
00330     _values[2] = z;
00331 }
00332 
00333 inline
00334 HxVec3Int::HxVec3Int(const HxVec3Int& v)
00335 {
00336     _values[0] = v._values[0];
00337     _values[1] = v._values[1];
00338     _values[2] = v._values[2];
00339 }
00340 
00341 inline void*
00342 HxVec3Int::operator new(size_t size, void *m) 
00343 {
00344     return m ? m : new char[size];
00345 }
00346 
00347 inline int
00348 HxVec3Int::dim() const 
00349 { 
00350     return 3;
00351 }
00352 
00353 inline int
00354 HxVec3Int::x() const 
00355 { 
00356     return _values[0]; 
00357 }
00358 
00359 inline int
00360 HxVec3Int::y() const 
00361 { 
00362     return _values[1]; 
00363 }
00364 
00365 inline int
00366 HxVec3Int::z() const 
00367 { 
00368     return _values[2]; 
00369 }
00370 
00371 inline int
00372 HxVec3Int::getValue(int dimension) const
00373 { 
00374     return _values[dimension - 1]; 
00375 }
00376 
00377 inline void
00378 HxVec3Int::setValue(int dimension, int value)
00379 { 
00380     _values[dimension - 1] = value; 
00381 }
00382 
00383 inline int
00384 HxVec3Int::operator==(const HxVec3Int& v) const
00385 {
00386     return (_values[0] == v._values[0]) && (_values[1] == v._values[1]) &&
00387            (_values[2] == v._values[2]);
00388 }
00389 
00390 inline int
00391 HxVec3Int::operator!=(const HxVec3Int& v) const
00392 {
00393     return (_values[0] != v._values[0]) || (_values[1] != v._values[1]) ||
00394            (_values[2] != v._values[2]);
00395 }
00396 
00397 inline int
00398 HxVec3Int::operator<(const HxVec3Int& v) const
00399 {
00400     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) <
00401            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00402 }
00403 
00404 inline int
00405 HxVec3Int::operator<=(const HxVec3Int& v) const
00406 {
00407     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) <=
00408            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00409 }
00410 
00411 inline int
00412 HxVec3Int::operator>(const HxVec3Int& v) const
00413 {
00414     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) >
00415            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00416 }
00417 
00418 inline int
00419 HxVec3Int::operator>=(const HxVec3Int& v) const
00420 {
00421     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) >=
00422            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00423 }
00424 
00425 inline HxVec3Int
00426 HxVec3Int::operator-() const
00427 {
00428     return HxVec3Int(-_values[0], -_values[1], -_values[2]);
00429 }
00430 
00431 inline HxVec3Int
00432 HxVec3Int::complement() const
00433 {
00434     return HxVec3Int(~_values[0], ~_values[1], ~_values[2]);
00435 }
00436 
00437 inline HxVec3Int
00438 HxVec3Int::abs() const
00439 {
00440     return HxVec3Int(::abs(_values[0]), ::abs(_values[1]), ::abs(_values[2]));
00441 }
00442 
00443 inline HxVec3Int
00444 HxVec3Int::ceil() const
00445 {
00446     return *this;
00447 }
00448 
00449 inline HxVec3Int
00450 HxVec3Int::floor() const
00451 {
00452     return *this;
00453 }
00454 
00455 inline HxVec3Int
00456 HxVec3Int::round() const
00457 {
00458     return *this;
00459 }
00460 
00461 inline HxScalarInt
00462 HxVec3Int::sum() const
00463 {
00464     return _values[0] + _values[1] + _values[2];
00465 }
00466 
00467 inline HxScalarInt
00468 HxVec3Int::product() const
00469 {
00470     return _values[0] * _values[1] * _values[2];
00471 }
00472 
00473 inline HxVec3Int&
00474 HxVec3Int::operator+=(const HxVec3Int& v)
00475 {
00476     _values[0] += v._values[0];
00477     _values[1] += v._values[1];
00478     _values[2] += v._values[2];
00479     return *this;
00480 }
00481 
00482 inline HxVec3Int&
00483 HxVec3Int::operator-=(const HxVec3Int& v)
00484 {
00485     _values[0] -= v._values[0];
00486     _values[1] -= v._values[1];
00487     _values[2] -= v._values[2];
00488     return *this;
00489 }
00490 
00491 inline HxVec3Int&
00492 HxVec3Int::operator*=(const HxVec3Int& v)
00493 {
00494     _values[0] *= v._values[0];
00495     _values[1] *= v._values[1];
00496     _values[2] *= v._values[2];
00497     return *this;
00498 }
00499 
00500 inline HxVec3Int&
00501 HxVec3Int::operator/=(const HxVec3Int& v)
00502 {
00503     _values[0] /= v._values[0];
00504     _values[1] /= v._values[1];
00505     _values[2] /= v._values[2];
00506     return *this;
00507 }
00508 
00509 inline HxVec3Int
00510 operator+(const HxVec3Int& v1, const HxVec3Int& v2)
00511 {
00512     return HxVec3Int(v1._values[0] + v2._values[0],
00513                      v1._values[1] + v2._values[1],
00514                      v1._values[2] + v2._values[2]);
00515 }
00516 
00517 inline HxVec3Int
00518 operator-(const HxVec3Int& v1, const HxVec3Int& v2)
00519 {
00520     return HxVec3Int(v1._values[0] - v2._values[0],
00521                      v1._values[1] - v2._values[1],
00522                      v1._values[2] - v2._values[2]);
00523 }
00524 
00525 inline HxVec3Int
00526 operator*(const HxVec3Int& v1, const HxVec3Int& v2)
00527 {
00528     return HxVec3Int(v1._values[0] * v2._values[0],
00529                      v1._values[1] * v2._values[1],
00530                      v1._values[2] * v2._values[2]);
00531 }
00532 
00533 inline HxVec3Int
00534 operator/(const HxVec3Int& v1, const HxVec3Int& v2)
00535 {
00536     return HxVec3Int(v1._values[0] / v2._values[0],
00537                      v1._values[1] / v2._values[1],
00538                      v1._values[2] / v2._values[2]);
00539 }
00540 
00541 inline HxVec3Int
00542 HxVec3Int::min(const HxVec3Int& v) const
00543 {
00544     return (operator<(v)) ? (*this) : v;
00545 }
00546 
00547 inline HxVec3Int&
00548 HxVec3Int::minAssign(const HxVec3Int& v)
00549 {
00550     if (operator<(v))
00551         return *this;
00552     operator=(v);
00553     return *this;
00554 }
00555 
00556 inline HxVec3Int
00557 HxVec3Int::max(const HxVec3Int& v) const
00558 {
00559     return (operator>(v)) ? (*this) : v;
00560 }
00561 
00562 inline HxVec3Int&
00563 HxVec3Int::maxAssign(const HxVec3Int& v)
00564 {
00565     if (operator>(v))
00566         return *this;
00567     operator=(v);
00568     return *this;
00569 }
00570 
00571 inline HxVec3Int
00572 HxVec3Int::inf(const HxVec3Int& v) const
00573 {
00574     return HxVec3Int((_values[0] < v._values[0]) ? _values[0] : v._values[0],
00575                      (_values[1] < v._values[1]) ? _values[1] : v._values[1],
00576                      (_values[2] < v._values[2]) ? _values[2] : v._values[2]);
00577 }
00578 
00579 inline HxVec3Int&
00580 HxVec3Int::infAssign(const HxVec3Int& v)
00581 {
00582     _values[0] = (_values[0] < v._values[0]) ? _values[0] : v._values[0];
00583     _values[1] = (_values[1] < v._values[1]) ? _values[1] : v._values[1];
00584     _values[2] = (_values[2] < v._values[2]) ? _values[2] : v._values[2];
00585     return *this;
00586 }
00587 
00588 inline HxVec3Int
00589 HxVec3Int::sup(const HxVec3Int& v) const
00590 {
00591     return HxVec3Int((_values[0] > v._values[0]) ? _values[0] : v._values[0],
00592                      (_values[1] > v._values[1]) ? _values[1] : v._values[1],
00593                      (_values[2] > v._values[2]) ? _values[2] : v._values[2]);
00594 }
00595 
00596 inline HxVec3Int&
00597 HxVec3Int::supAssign(const HxVec3Int& v)
00598 {
00599     _values[0] = (_values[0] > v._values[0]) ? _values[0] : v._values[0];
00600     _values[1] = (_values[1] > v._values[1]) ? _values[1] : v._values[1];
00601     _values[2] = (_values[2] > v._values[2]) ? _values[2] : v._values[2];
00602     return *this;
00603 }
00604 
00605 inline HxVec3Int
00606 HxVec3Int::pow(const HxVec3Int& v) const
00607 {
00608     return HxVec3Int((int) (::pow(_values[0], v._values[0]) + 0.5),
00609                      (int) (::pow(_values[1], v._values[1]) + 0.5),
00610                      (int) (::pow(_values[2], v._values[2]) + 0.5));
00611 }
00612 
00613 inline HxVec3Int
00614 HxVec3Int::mod(const HxVec3Int& v) const
00615 {
00616     return HxVec3Int(_values[0] % v._values[0],
00617                      _values[1] % v._values[1],
00618                      _values[2] % v._values[2]);
00619 }
00620 
00621 inline HxVec3Int
00622 HxVec3Int::and(const HxVec3Int& v) const
00623 {
00624     return HxVec3Int(_values[0] & v._values[0],
00625                      _values[1] & v._values[1],
00626                      _values[2] & v._values[2]);
00627 }
00628 
00629 inline HxVec3Int
00630 HxVec3Int::or(const HxVec3Int& v) const
00631 {
00632     return HxVec3Int(_values[0] | v._values[0],
00633                      _values[1] | v._values[1],
00634                      _values[2] | v._values[2]);
00635 }
00636 
00637 inline HxVec3Int
00638 HxVec3Int::xor(const HxVec3Int& v) const
00639 {
00640     return HxVec3Int(_values[0] ^ v._values[0],
00641                      _values[1] ^ v._values[1],
00642                      _values[2] ^ v._values[2]);
00643 }
00644 
00645 inline HxVec3Int
00646 HxVec3Int::leftShift(const HxVec3Int& v) const
00647 {
00648     return HxVec3Int(_values[0] << v._values[0],
00649                      _values[1] << v._values[1],
00650                      _values[2] << v._values[2]);
00651 }
00652 
00653 inline HxVec3Int
00654 HxVec3Int::rightShift(const HxVec3Int& v) const
00655 {
00656     return HxVec3Int(_values[0] >> v._values[0],
00657                      _values[1] >> v._values[1],
00658                      _values[2] >> v._values[2]);
00659 }
00660 
00661 inline HxVec3Int
00662 HxVec3Int::cross(const HxVec3Int& v) const
00663 {
00664     return HxVec3Int(_values[1] * v._values[2] - _values[2] * v._values[1],
00665                      _values[2] * v._values[0] - _values[0] * v._values[2],
00666                      _values[0] * v._values[1] - _values[1] * v._values[0]);
00667 }
00668 
00669 #endif
Generated on Tue Feb 3 14:18:44 2004 for C++Reference by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001