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 private:
00039 typedef DERIVED Base;
00040 public:
00041
00042
00043
00045 typedef Scalar value_type;
00046
00048 typedef VectorT<Scalar,DIM> vector_type;
00049
00051 static inline int dim() { return DIM; }
00052
00054 static inline size_t size() { return DIM; }
00055
00056 static const size_t size_ = DIM;
00057
00058
00059
00060
00062 inline VectorT() {}
00063
00065 explicit inline VectorT(const Scalar& v) {
00066
00067
00068 vectorize(v);
00069 }
00070
00072 inline VectorT(const Scalar& v0, const Scalar& v1) {
00073 assert(DIM==2);
00074 Base::values_[0] = v0; Base::values_[1] = v1;
00075 }
00076
00078 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2) {
00079 assert(DIM==3);
00080 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
00081 }
00082
00084 inline VectorT(const Scalar& v0, const Scalar& v1,
00085 const Scalar& v2, const Scalar& v3) {
00086 assert(DIM==4);
00087 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2; Base::values_[3]=v3;
00088 }
00089
00091 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00092 const Scalar& v3, const Scalar& v4) {
00093 assert(DIM==5);
00094 Base::values_[0]=v0; Base::values_[1]=v1;Base::values_[2]=v2; Base::values_[3]=v3; Base::values_[4]=v4;
00095 }
00096
00098 inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00099 const Scalar& v3, const Scalar& v4, const Scalar& v5) {
00100 assert(DIM==6);
00101 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
00102 Base::values_[3]=v3; Base::values_[4]=v4; Base::values_[5]=v5;
00103 }
00104
00106 explicit inline VectorT(const Scalar _values[DIM]) {
00107 memcpy(Base::values_, _values, DIM*sizeof(Scalar));
00108 }
00109
00110
00111 #ifdef OM_CC_MIPS
00113 // mipspro need this method
00114 inline vector_type& operator=(const vector_type& _rhs) {
00115 memcpy(Base::values_, _rhs.Base::values_, DIM*sizeof(Scalar));
00116 return *this;
00117 }
00118 #endif
00119
00120
00122 template<typename otherScalarType>
00123 explicit inline VectorT(const VectorT<otherScalarType,DIM>& _rhs) {
00124 operator=(_rhs);
00125 }
00126
00127
00128
00129
00130
00131
00133 template<typename otherScalarType>
00134 inline vector_type& operator=(const VectorT<otherScalarType,DIM>& _rhs) {
00135 #define expr(i) Base::values_[i] = (Scalar)_rhs[i];
00136 unroll(expr);
00137 #undef expr
00138 return *this;
00139 }
00140
00141
00142
00143
00144
00145
00146
00148 inline Scalar* data() { return Base::values_; }
00149
00151 inline const Scalar*data() const { return Base::values_; }
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00169 inline Scalar& operator[](size_t _i) {
00170 assert(_i<DIM); return Base::values_[_i];
00171 }
00172
00174 inline const Scalar& operator[](size_t _i) const {
00175 assert(_i<DIM); return Base::values_[_i];
00176 }
00177
00178
00179
00180
00181
00182
00184 inline bool operator==(const vector_type& _rhs) const {
00185 #define expr(i) if(Base::values_[i]!=_rhs.Base::values_[i]) return false;
00186 unroll(expr);
00187 #undef expr
00188 return true;
00189 }
00190
00192 inline bool operator!=(const vector_type& _rhs) const {
00193 return !(*this == _rhs);
00194 }
00195
00196
00197
00198
00199
00200
00202 inline vector_type& operator*=(const Scalar& _s) {
00203 #define expr(i) Base::values_[i] *= _s;
00204 unroll(expr);
00205 #undef expr
00206 return *this;
00207 }
00208
00211 inline vector_type& operator/=(const Scalar& _s) {
00212 #define expr(i) Base::values_[i] /= _s;
00213 unroll(expr);
00214 #undef expr
00215 return *this;
00216 }
00217
00218
00220 inline vector_type operator*(const Scalar& _s) const {
00221 #if DIM==N
00222 return vector_type(*this) *= _s;
00223 #else
00224 #define expr(i) Base::values_[i] * _s
00225 return vector_type(unroll_csv(expr));
00226 #undef expr
00227 #endif
00228 }
00229
00230
00232 inline vector_type operator/(const Scalar& _s) const {
00233 #if DIM==N
00234 return vector_type(*this) /= _s;
00235 #else
00236 #define expr(i) Base::values_[i] / _s
00237 return vector_type(unroll_csv(expr));
00238 #undef expr
00239 #endif
00240 }
00241
00242
00243
00244
00245
00246
00247
00248
00250 inline vector_type& operator*=(const vector_type& _rhs) {
00251 #define expr(i) Base::values_[i] *= _rhs[i];
00252 unroll(expr);
00253 #undef expr
00254 return *this;
00255 }
00256
00258 inline vector_type& operator/=(const vector_type& _rhs) {
00259 #define expr(i) Base::values_[i] /= _rhs[i];
00260 unroll(expr);
00261 #undef expr
00262 return *this;
00263 }
00264
00266 inline vector_type& operator-=(const vector_type& _rhs) {
00267 #define expr(i) Base::values_[i] -= _rhs[i];
00268 unroll(expr);
00269 #undef expr
00270 return *this;
00271 }
00272
00274 inline vector_type& operator+=(const vector_type& _rhs) {
00275 #define expr(i) Base::values_[i] += _rhs[i];
00276 unroll(expr);
00277 #undef expr
00278 return *this;
00279 }
00280
00281
00283 inline vector_type operator*(const vector_type& _v) const {
00284 #if DIM==N
00285 return vector_type(*this) *= _v;
00286 #else
00287 #define expr(i) Base::values_[i] * _v.Base::values_[i]
00288 return vector_type(unroll_csv(expr));
00289 #undef expr
00290 #endif
00291 }
00292
00293
00295 inline vector_type operator/(const vector_type& _v) const {
00296 #if DIM==N
00297 return vector_type(*this) /= _v;
00298 #else
00299 #define expr(i) Base::values_[i] / _v.Base::values_[i]
00300 return vector_type(unroll_csv(expr));
00301 #undef expr
00302 #endif
00303 }
00304
00305
00307 inline vector_type operator+(const vector_type& _v) const {
00308 #if DIM==N
00309 return vector_type(*this) += _v;
00310 #else
00311 #define expr(i) Base::values_[i] + _v.Base::values_[i]
00312 return vector_type(unroll_csv(expr));
00313 #undef expr
00314 #endif
00315 }
00316
00317
00319 inline vector_type operator-(const vector_type& _v) const {
00320 #if DIM==N
00321 return vector_type(*this) -= _v;
00322 #else
00323 #define expr(i) Base::values_[i] - _v.Base::values_[i]
00324 return vector_type(unroll_csv(expr));
00325 #undef expr
00326 #endif
00327 }
00328
00329
00331 inline vector_type operator-(void) const {
00332 vector_type v;
00333 #define expr(i) v.Base::values_[i] = -Base::values_[i];
00334 unroll(expr);
00335 #undef expr
00336 return v;
00337 }
00338
00339
00342 inline VectorT<Scalar,3> operator%(const VectorT<Scalar,3>& _rhs) const
00343 #if DIM==3
00344 {
00345 return
00346 VectorT<Scalar,3>(Base::values_[1]*_rhs.Base::values_[2]-Base::values_[2]*_rhs.Base::values_[1],
00347 Base::values_[2]*_rhs.Base::values_[0]-Base::values_[0]*_rhs.Base::values_[2],
00348 Base::values_[0]*_rhs.Base::values_[1]-Base::values_[1]*_rhs.Base::values_[0]);
00349 }
00350 #else
00351 ;
00352 #endif
00353
00354
00357 inline Scalar operator|(const vector_type& _rhs) const {
00358 Scalar p(0);
00359 #define expr(i) p += Base::values_[i] * _rhs.Base::values_[i];
00360 unroll(expr);
00361 #undef expr
00362 return p;
00363 }
00364
00365
00366
00367
00368
00369
00370
00372
00373
00374 inline Scalar norm() const { return (Scalar)sqrt(sqrnorm()); }
00375 inline Scalar length() const { return norm(); }
00376
00378 inline Scalar sqrnorm() const
00379 {
00380 #if DIM==N
00381 Scalar s(0);
00382 #define expr(i) s += Base::values_[i] * Base::values_[i];
00383 unroll(expr);
00384 #undef expr
00385 return s;
00386 #else
00387 #define expr(i) Base::values_[i]*Base::values_[i]
00388 return (unroll_comb(expr, +));
00389 #undef expr
00390 #endif
00391 }
00393
00397 inline vector_type& normalize()
00398 {
00399 *this /= norm();
00400 return *this;
00401 }
00402
00405 inline vector_type& normalize_cond()
00406 {
00407 Scalar n = norm();
00408 if (n != (Scalar)0.0)
00409 {
00410 *this /= n;
00411 }
00412 return *this;
00413 }
00414
00415
00416
00417
00419 inline Scalar max() const
00420 {
00421 Scalar m(Base::values_[0]);
00422 for(int i=1; i<DIM; ++i) if(Base::values_[i]>m) m=Base::values_[i];
00423 return m;
00424 }
00425
00427 inline Scalar min() const
00428 {
00429 Scalar m(Base::values_[0]);
00430 for(int i=1; i<DIM; ++i) if(Base::values_[i]<m) m=Base::values_[i];
00431 return m;
00432 }
00433
00435 inline Scalar mean() const {
00436 Scalar m(Base::values_[0]);
00437 for(int i=1; i<DIM; ++i) m+=Base::values_[i];
00438 return m/Scalar(DIM);
00439 }
00440
00442 inline vector_type minimize(const vector_type& _rhs) {
00443 #define expr(i) if (_rhs[i] < Base::values_[i]) Base::values_[i] = _rhs[i];
00444 unroll(expr);
00445 #undef expr
00446 return *this;
00447 }
00448
00450 inline vector_type maximize(const vector_type& _rhs) {
00451 #define expr(i) if (_rhs[i] > Base::values_[i]) Base::values_[i] = _rhs[i];
00452 unroll(expr);
00453 #undef expr
00454 return *this;
00455 }
00456
00458 inline vector_type min(const vector_type& _rhs) {
00459 return vector_type(*this).minimize(_rhs);
00460 }
00461
00463 inline vector_type max(const vector_type& _rhs) {
00464 return vector_type(*this).maximize(_rhs);
00465 }
00466
00467
00468
00469
00470
00471
00473 template<typename Functor>
00474 inline vector_type apply(const Functor& _func) const {
00475 vector_type result;
00476 #define expr(i) result[i] = _func(Base::values_[i]);
00477 unroll(expr);
00478 #undef expr
00479 return result;
00480 }
00481
00483 vector_type& vectorize(const Scalar& _s) {
00484 #define expr(i) Base::values_[i] = _s;
00485 unroll(expr);
00486 #undef expr
00487 return *this;
00488 }
00489
00490
00492 static vector_type vectorized(const Scalar& _s) {
00493 return vector_type().vectorize(_s);
00494 }
00495
00496
00498 bool operator<(const vector_type& _rhs) const {
00499 #define expr(i) if (Base::values_[i] != _rhs.Base::values_[i]) \
00500 return (Base::values_[i] < _rhs.Base::values_[i]);
00501 unroll(expr);
00502 #undef expr
00503 return false;
00504 }
00505 };
00506
00507
00508
00510 TEMPLATE_HEADER
00511 inline std::istream&
00512 operator>>(std::istream& is, VectorT<Scalar,DIM>& vec)
00513 {
00514 #define expr(i) is >> vec[i];
00515 unroll(expr);
00516 #undef expr
00517 return is;
00518 }
00519
00520
00522 TEMPLATE_HEADER
00523 inline std::ostream&
00524 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
00525 {
00526 #if DIM==N
00527 for(int i=0; i<N-1; ++i) os << vec[i] << " ";
00528 os << vec[N-1];
00529 #else
00530 #define expr(i) vec[i]
00531 os << unroll_comb(expr, << " " <<);
00532 #undef expr
00533 #endif
00534
00535 return os;
00536 }
00537
00538
00539
00540 #endif // included by VectorT.hh
00541