00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #if defined( OPENMESH_VECTOR_HH )
00032
00033
00034
00035 TEMPLATE_HEADER
00036 class CLASSNAME : public DERIVED
00037 {
00038 public:
00039
00040
00041
00043 typedef Scalar value_type;
00044
00046 typedef VectorT<Scalar,DIM> vector_type;
00047
00049 static inline int dim() { return DIM; }
00050
00052 static inline size_t size() { return DIM; }
00053
00054 static const size_t size_ = DIM;
00055
00056
00057
00058
00060 inline VectorT() {}
00061
00063 explicit inline VectorT(const Scalar& v) {
00064
00065
00066 vectorize(v);
00067 }
00068
00070 inline VectorT(const Scalar& v0, const Scalar& v1) {
00071 assert(DIM==2);
00072 this->values_[0] = v0; this->values_[1] = v1;
00073 }
00074
00076 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2) {
00077 assert(DIM==3);
00078 this->values_[0]=v0; this->values_[1]=v1; this->values_[2]=v2;
00079 }
00080
00082 inline VectorT(const Scalar& v0, const Scalar& v1,
00083 const Scalar& v2, const Scalar& v3) {
00084 assert(DIM==4);
00085 this->values_[0]=v0; this->values_[1]=v1; this->values_[2]=v2; this->values_[3]=v3;
00086 }
00087
00089 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00090 const Scalar& v3, const Scalar& v4) {
00091 assert(DIM==5);
00092 this->values_[0]=v0; this->values_[1]=v1;this->values_[2]=v2; this->values_[3]=v3; this->values_[4]=v4;
00093 }
00094
00096 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00097 const Scalar& v3, const Scalar& v4, const Scalar& v5) {
00098 assert(DIM==6);
00099 this->values_[0]=v0; this->values_[1]=v1; this->values_[2]=v2;
00100 this->values_[3]=v3; this->values_[4]=v4; this->values_[5]=v5;
00101 }
00102
00104 explicit inline VectorT(const Scalar _values[DIM]) {
00105 memcpy(this->values_, _values, DIM*sizeof(Scalar));
00106 }
00107
00108
00109 #ifdef OM_CC_MIPS
00111 // mipspro need this method
00112 inline vector_type& operator=(const vector_type& _rhs) {
00113 memcpy(this->values_, _rhs.values_, DIM*sizeof(Scalar));
00114 return *this;
00115 }
00116 #endif
00117
00118
00120 template<typename otherScalarType>
00121 explicit inline VectorT(const VectorT<otherScalarType,DIM>& _rhs) {
00122 operator=(_rhs);
00123 }
00124
00125
00126
00127
00128
00129
00131 template<typename otherScalarType>
00132 inline vector_type& operator=(const VectorT<otherScalarType,DIM>& _rhs) {
00133 #define expr(i) this->values_[i] = (Scalar)_rhs[i];
00134 unroll(expr);
00135 #undef expr
00136 return *this;
00137 }
00138
00139
00141 inline Scalar* data() { return this->values_; }
00142
00144 inline const Scalar*data() const { return this->values_; }
00145
00146
00147
00148
00149
00150
00152 inline Scalar& operator[](size_t _i) {
00153 assert(_i>=0 && _i<DIM); return this->values_[_i];
00154 }
00155
00157 inline const Scalar& operator[](size_t _i) const {
00158 assert(_i>=0 && _i<DIM); return this->values_[_i];
00159 }
00160
00161
00162
00163
00164
00166 inline bool operator==(const vector_type& _rhs) const {
00167 #define expr(i) if(this->values_[i]!=_rhs.values_[i]) return false;
00168 unroll(expr);
00169 #undef expr
00170 return true;
00171 }
00172
00174 inline bool operator!=(const vector_type& _rhs) const {
00175 return !(*this == _rhs);
00176 }
00177
00178
00179
00180
00181
00182
00184 inline vector_type& operator*=(const Scalar& _s) {
00185 #define expr(i) this->values_[i] *= _s;
00186 unroll(expr);
00187 #undef expr
00188 return *this;
00189 }
00190
00193 inline vector_type& operator/=(const Scalar& _s) {
00194 #define expr(i) this->values_[i] /= _s;
00195 unroll(expr);
00196 #undef expr
00197 return *this;
00198 }
00199
00200
00202 inline vector_type operator*(const Scalar& _s) const {
00203 #if DIM==N
00204 return vector_type(*this) *= _s;
00205 #else
00206 #define expr(i) this->values_[i] * _s
00207 return vector_type(unroll_csv(expr));
00208 #undef expr
00209 #endif
00210 }
00211
00212
00214 inline vector_type operator/(const Scalar& _s) const {
00215 #if DIM==N
00216 return vector_type(*this) /= _s;
00217 #else
00218 #define expr(i) this->values_[i] / _s
00219 return vector_type(unroll_csv(expr));
00220 #undef expr
00221 #endif
00222 }
00223
00224
00225
00226
00227
00228
00229
00230
00232 inline vector_type& operator*=(const vector_type& _rhs) {
00233 #define expr(i) this->values_[i] *= _rhs[i];
00234 unroll(expr);
00235 #undef expr
00236 return *this;
00237 }
00238
00240 inline vector_type& operator/=(const vector_type& _rhs) {
00241 #define expr(i) this->values_[i] /= _rhs[i];
00242 unroll(expr);
00243 #undef expr
00244 return *this;
00245 }
00246
00248 inline vector_type& operator-=(const vector_type& _rhs) {
00249 #define expr(i) this->values_[i] -= _rhs[i];
00250 unroll(expr);
00251 #undef expr
00252 return *this;
00253 }
00254
00256 inline vector_type& operator+=(const vector_type& _rhs) {
00257 #define expr(i) this->values_[i] += _rhs[i];
00258 unroll(expr);
00259 #undef expr
00260 return *this;
00261 }
00262
00263
00265 inline vector_type operator*(const vector_type& _v) const {
00266 #if DIM==N
00267 return vector_type(*this) *= _v;
00268 #else
00269 #define expr(i) this->values_[i] * _v.values_[i]
00270 return vector_type(unroll_csv(expr));
00271 #undef expr
00272 #endif
00273 }
00274
00275
00277 inline vector_type operator/(const vector_type& _v) const {
00278 #if DIM==N
00279 return vector_type(*this) /= _v;
00280 #else
00281 #define expr(i) this->values_[i] / _v.values_[i]
00282 return vector_type(unroll_csv(expr));
00283 #undef expr
00284 #endif
00285 }
00286
00287
00289 inline vector_type operator+(const vector_type& _v) const {
00290 #if DIM==N
00291 return vector_type(*this) += _v;
00292 #else
00293 #define expr(i) this->values_[i] + _v.values_[i]
00294 return vector_type(unroll_csv(expr));
00295 #undef expr
00296 #endif
00297 }
00298
00299
00301 inline vector_type operator-(const vector_type& _v) const {
00302 #if DIM==N
00303 return vector_type(*this) -= _v;
00304 #else
00305 #define expr(i) this->values_[i] - _v.values_[i]
00306 return vector_type(unroll_csv(expr));
00307 #undef expr
00308 #endif
00309 }
00310
00311
00313 inline vector_type operator-(void) const {
00314 vector_type v;
00315 #define expr(i) v.values_[i] = -this->values_[i];
00316 unroll(expr);
00317 #undef expr
00318 return v;
00319 }
00320
00321
00324 inline VectorT<Scalar,3> operator%(const VectorT<Scalar,3>& _rhs) const
00325 #if DIM==3
00326 {
00327 return
00328 VectorT<Scalar,3>(this->values_[1]*_rhs.values_[2]-this->values_[2]*_rhs.values_[1],
00329 this->values_[2]*_rhs.values_[0]-this->values_[0]*_rhs.values_[2],
00330 this->values_[0]*_rhs.values_[1]-this->values_[1]*_rhs.values_[0]);
00331 }
00332 #else
00333 ;
00334 #endif
00335
00336
00339 inline Scalar operator|(const vector_type& _rhs) const {
00340 Scalar p(0);
00341 #define expr(i) p += this->values_[i] * _rhs.values_[i];
00342 unroll(expr);
00343 #undef expr
00344 return p;
00345 }
00346
00347
00348
00349
00350
00351
00352
00354
00355
00356 inline Scalar norm() const { return (Scalar)sqrt(sqrnorm()); }
00357 inline Scalar length() const { return norm(); }
00358
00360 inline Scalar sqrnorm() const {
00361 #if DIM==N
00362 Scalar s(0);
00363 #define expr(i) s += this->values_[i] * this->values_[i];
00364 unroll(expr);
00365 #undef expr
00366 return s;
00367 #else
00368 #define expr(i) this->values_[i]*this->values_[i]
00369 return (unroll_comb(expr, +));
00370 #undef expr
00371 #endif
00372 }
00374
00377 inline vector_type& normalize() {
00378 #ifdef NDEBUG
00379 operator*=(((Scalar)1.0)/norm());
00380 #else
00381 Scalar n = norm();
00382 if (n != (Scalar)0.0)
00383 *this *= Scalar(1.0/n);
00384 #endif
00385 return *this;
00386 }
00387
00388
00389
00390
00391
00393 inline Scalar max() const {
00394 Scalar m(this->values_[0]);
00395 for(int i=1; i<DIM; ++i) if(this->values_[i]>m) m=this->values_[i];
00396 return m;
00397 }
00398
00400 inline Scalar min() const {
00401 Scalar m(this->values_[0]);
00402 for(int i=1; i<DIM; ++i) if(this->values_[i]<m) m=this->values_[i];
00403 return m;
00404 }
00405
00407 inline Scalar mean() const {
00408 Scalar m(this->values_[0]);
00409 for(int i=1; i<DIM; ++i) m+=this->values_[i];
00410 return m/Scalar(DIM);
00411 }
00412
00414 inline vector_type& minimize(const vector_type& _rhs) {
00415 #define expr(i) if (_rhs[i] < this->values_[i]) this->values_[i] = _rhs[i];
00416 unroll(expr);
00417 #undef expr
00418 return *this;
00419 }
00420
00422 inline vector_type& maximize(const vector_type& _rhs) {
00423 #define expr(i) if (_rhs[i] > this->values_[i]) this->values_[i] = _rhs[i];
00424 unroll(expr);
00425 #undef expr
00426 return *this;
00427 }
00428
00430 inline vector_type min(const vector_type& _rhs) {
00431 return vector_type(*this).minimize(_rhs);
00432 }
00433
00435 inline vector_type max(const vector_type& _rhs) {
00436 return vector_type(*this).maximize(_rhs);
00437 }
00438
00439
00440
00441
00442
00443
00445 template<typename Functor>
00446 inline vector_type apply(const Functor& _func) const {
00447 vector_type result;
00448 #define expr(i) result[i] = _func(this->values_[i]);
00449 unroll(expr);
00450 #undef expr
00451 return result;
00452 }
00453
00455 vector_type& vectorize(const Scalar& _s) {
00456 #define expr(i) this->values_[i] = _s;
00457 unroll(expr);
00458 #undef expr
00459 return *this;
00460 }
00461
00462
00464 static vector_type vectorized(const Scalar& _s) {
00465 return vector_type().vectorize(_s);
00466 }
00467
00468
00470 bool operator<(const vector_type& _rhs) const {
00471 #define expr(i) if (this->values_[i] != _rhs.values_[i]) \
00472 return (this->values_[i] < _rhs.values_[i]);
00473 unroll(expr);
00474 #undef expr
00475 return false;
00476 }
00477 };
00478
00479
00480
00482 TEMPLATE_HEADER
00483 inline std::istream&
00484 operator>>(std::istream& is, VectorT<Scalar,DIM>& vec)
00485 {
00486 #define expr(i) is >> vec[i];
00487 unroll(expr);
00488 #undef expr
00489 return is;
00490 }
00491
00492
00494 TEMPLATE_HEADER
00495 inline std::ostream&
00496 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
00497 {
00498 #if DIM==N
00499 for(int i=0; i<N-1; ++i) os << vec[i] << " ";
00500 os << vec[N-1];
00501 #else
00502 #define expr(i) vec[i]
00503 os << unroll_comb(expr, << " " <<);
00504 #undef expr
00505 #endif
00506
00507 return os;
00508 }
00509
00510
00511
00512 #endif // included by VectorT.hh
00513