OpenMesh: src/OpenMesh/Core/Geometry/VectorT

00001 /*===========================================================================*\
00002  *                                                                           *
00003  *                               OpenMesh                                    *
00004  *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
00005  *                           www.openmesh.org                                *
00006  *                                                                           *
00007  *---------------------------------------------------------------------------* 
00008  *  This file is part of OpenMesh.                                           *
00009  *                                                                           *
00010  *  OpenMesh is free software: you can redistribute it and/or modify         * 
00011  *  it under the terms of the GNU Lesser General Public License as           *
00012  *  published by the Free Software Foundation, either version 3 of           *
00013  *  the License, or (at your option) any later version with the              *
00014  *  following exceptions:                                                    *
00015  *                                                                           *
00016  *  If other files instantiate templates or use macros                       *
00017  *  or inline functions from this file, or you compile this file and         *
00018  *  link it with other files to produce an executable, this file does        *
00019  *  not by itself cause the resulting executable to be covered by the        *
00020  *  GNU Lesser General Public License. This exception does not however       *
00021  *  invalidate any other reasons why the executable file might be            *
00022  *  covered by the GNU Lesser General Public License.                        *
00023  *                                                                           *
00024  *  OpenMesh is distributed in the hope that it will be useful,              *
00025  *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
00026  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
00027  *  GNU Lesser General Public License for more details.                      *
00028  *                                                                           *
00029  *  You should have received a copy of the GNU LesserGeneral Public          *
00030  *  License along with OpenMesh.  If not,                                    *
00031  *  see <http://www.gnu.org/licenses/>.                                      *
00032  *                                                                           *
00033 \*===========================================================================*/ 
00034 
00035 /*===========================================================================*\
00036  *                                                                           *             
00037  *   $Revision: 137 $                                                         *
00038  *   $Date: 2009-06-04 10:46:29 +0200 (Do, 04. Jun 2009) $                   *
00039  *                                                                           *
00040 \*===========================================================================*/
00041 
00042 #if defined( OPENMESH_VECTOR_HH )
00043 
00044 // ----------------------------------------------------------------------------
00045 
00046 TEMPLATE_HEADER
00047 class CLASSNAME : public DERIVED
00048 {
00049 private:
00050   typedef DERIVED                           Base;
00051 public:
00052 
00053   //---------------------------------------------------------------- class info
00054 
00056   typedef Scalar value_type;
00057 
00059   typedef VectorT<Scalar,DIM>  vector_type;
00060 
00062   static inline int dim() { return DIM; }
00063 
00065   static inline size_t size() { return DIM; }
00066 
00067   static const size_t size_ = DIM;
00068 
00069 
00070   //-------------------------------------------------------------- constructors
00071 
00073   inline VectorT() {}
00074 
00076   explicit inline VectorT(const Scalar& v) {
00077 //     assert(DIM==1);
00078 //     values_[0] = v0;
00079     vectorize(v);
00080   }
00081 
00083   inline VectorT(const Scalar& v0, const Scalar& v1) {
00084     assert(DIM==2);
00085     Base::values_[0] = v0; Base::values_[1] = v1;
00086   }
00087 
00089   inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2) {
00090     assert(DIM==3);
00091     Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
00092   }
00093 
00095   inline VectorT(const Scalar& v0, const Scalar& v1,
00096      const Scalar& v2, const Scalar& v3) {
00097     assert(DIM==4);
00098     Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2; Base::values_[3]=v3;
00099   }
00100 
00102   inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00103      const Scalar& v3, const Scalar& v4) {
00104     assert(DIM==5);
00105     Base::values_[0]=v0; Base::values_[1]=v1;Base::values_[2]=v2; Base::values_[3]=v3; Base::values_[4]=v4;
00106   }
00107 
00109   inline VectorT(const Scalar& v0, const Scalar& v1, const Scalar& v2,
00110      const Scalar& v3, const Scalar& v4, const Scalar& v5) {
00111     assert(DIM==6);
00112     Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
00113     Base::values_[3]=v3; Base::values_[4]=v4; Base::values_[5]=v5;
00114   }
00115 
00117   explicit inline VectorT(const Scalar _values[DIM]) {
00118     memcpy(Base::values_, _values, DIM*sizeof(Scalar));
00119   }
00120 
00121 
00122 #ifdef OM_CC_MIPS
00123 
00124   // mipspro need this method
00125   inline vector_type& operator=(const vector_type& _rhs) {
00126     memcpy(Base::values_, _rhs.Base::values_, DIM*sizeof(Scalar));
00127     return *this;
00128   }
00129 #endif
00130 
00131 
00133   template<typename otherScalarType>
00134   explicit inline VectorT(const VectorT<otherScalarType,DIM>& _rhs) {
00135     operator=(_rhs);
00136   }
00137 
00138 
00139 
00140 
00141   //--------------------------------------------------------------------- casts
00142 
00144   template<typename otherScalarType>
00145   inline vector_type& operator=(const VectorT<otherScalarType,DIM>& _rhs) {
00146 #define expr(i)  Base::values_[i] = (Scalar)_rhs[i];
00147     unroll(expr);
00148 #undef expr
00149     return *this;
00150   }
00151 
00152 //   /// cast to Scalar array
00153 //   inline operator Scalar*() { return Base::values_; }
00154 
00155 //   /// cast to const Scalar array
00156 //   inline operator const Scalar*() const { return Base::values_; }
00157 
00159   inline Scalar* data() { return Base::values_; }
00160 
00162   inline const Scalar*data() const { return Base::values_; }
00163 
00164 
00165 
00166 
00167    //----------------------------------------------------------- element access
00168 
00169 //    /// get i'th element read-write
00170 //   inline Scalar& operator[](int _i) {
00171 //     assert(_i>=0 && _i<DIM); return Base::values_[_i];
00172 //   }
00173 
00174 //   /// get i'th element read-only
00175 //   inline const Scalar& operator[](int _i) const {
00176 //     assert(_i>=0 && _i<DIM); return Base::values_[_i];
00177 //   }
00178 
00180   inline Scalar& operator[](size_t _i) {
00181     assert(_i<DIM); return Base::values_[_i];
00182   }
00183 
00185   inline const Scalar& operator[](size_t _i) const {
00186     assert(_i<DIM); return Base::values_[_i];
00187   }
00188 
00189 
00190 
00191 
00192   //---------------------------------------------------------------- comparsion
00193 
00195   inline bool operator==(const vector_type& _rhs) const {
00196 #define expr(i) if(Base::values_[i]!=_rhs.Base::values_[i]) return false;
00197     unroll(expr);
00198 #undef expr
00199     return true;
00200   }
00201 
00203   inline bool operator!=(const vector_type& _rhs) const {
00204     return !(*this == _rhs);
00205   }
00206 
00207 
00208 
00209 
00210   //---------------------------------------------------------- scalar operators
00211 
00213   inline vector_type& operator*=(const Scalar& _s) {
00214 #define expr(i) Base::values_[i] *= _s;
00215     unroll(expr);
00216 #undef expr
00217     return *this;
00218   }
00219 
00222   inline vector_type& operator/=(const Scalar& _s) {
00223 #define expr(i) Base::values_[i] /= _s;
00224     unroll(expr);
00225 #undef expr
00226     return *this;
00227   }
00228 
00229 
00231   inline vector_type operator*(const Scalar& _s) const {
00232 #if DIM==N
00233     return vector_type(*this) *= _s;
00234 #else
00235 #define expr(i) Base::values_[i] * _s
00236     return vector_type(unroll_csv(expr));
00237 #undef expr
00238 #endif
00239   }
00240 
00241 
00243   inline vector_type operator/(const Scalar& _s) const {
00244 #if DIM==N
00245     return vector_type(*this) /= _s;
00246 #else
00247 #define expr(i) Base::values_[i] / _s
00248     return vector_type(unroll_csv(expr));
00249 #undef expr
00250 #endif
00251   }
00252 
00253 
00254 
00255 
00256 
00257 
00258   //---------------------------------------------------------- vector operators
00259 
00261   inline vector_type& operator*=(const vector_type& _rhs) {
00262 #define expr(i) Base::values_[i] *= _rhs[i];
00263     unroll(expr);
00264 #undef expr
00265     return *this;
00266   }
00267 
00269   inline vector_type& operator/=(const vector_type& _rhs) {
00270 #define expr(i) Base::values_[i] /= _rhs[i];
00271     unroll(expr);
00272 #undef expr
00273     return *this;
00274   }
00275 
00277   inline vector_type& operator-=(const vector_type& _rhs) {
00278 #define expr(i) Base::values_[i] -= _rhs[i];
00279     unroll(expr);
00280 #undef expr
00281     return *this;
00282   }
00283 
00285   inline vector_type& operator+=(const vector_type& _rhs) {
00286 #define expr(i) Base::values_[i] += _rhs[i];
00287     unroll(expr);
00288 #undef expr
00289     return *this;
00290   }
00291 
00292 
00294   inline vector_type operator*(const vector_type& _v) const {
00295 #if DIM==N
00296     return vector_type(*this) *= _v;
00297 #else
00298 #define expr(i) Base::values_[i] * _v.Base::values_[i]
00299     return vector_type(unroll_csv(expr));
00300 #undef expr
00301 #endif
00302   }
00303 
00304 
00306   inline vector_type operator/(const vector_type& _v) const {
00307 #if DIM==N
00308     return vector_type(*this) /= _v;
00309 #else
00310 #define expr(i) Base::values_[i] / _v.Base::values_[i]
00311     return vector_type(unroll_csv(expr));
00312 #undef expr
00313 #endif
00314   }
00315 
00316 
00318   inline vector_type operator+(const vector_type& _v) const {
00319 #if DIM==N
00320     return vector_type(*this) += _v;
00321 #else
00322 #define expr(i) Base::values_[i] + _v.Base::values_[i]
00323     return vector_type(unroll_csv(expr));
00324 #undef expr
00325 #endif
00326   }
00327 
00328 
00330   inline vector_type operator-(const vector_type& _v) const {
00331 #if DIM==N
00332     return vector_type(*this) -= _v;
00333 #else
00334 #define expr(i) Base::values_[i] - _v.Base::values_[i]
00335     return vector_type(unroll_csv(expr));
00336 #undef expr
00337 #endif
00338   }
00339 
00340 
00342   inline vector_type operator-(void) const {
00343     vector_type v;
00344 #define expr(i) v.Base::values_[i] = -Base::values_[i];
00345     unroll(expr);
00346 #undef expr
00347     return v;
00348   }
00349 
00350 
00353   inline VectorT<Scalar,3> operator%(const VectorT<Scalar,3>& _rhs) const
00354 #if DIM==3
00355   {
00356     return
00357       VectorT<Scalar,3>(Base::values_[1]*_rhs.Base::values_[2]-Base::values_[2]*_rhs.Base::values_[1],
00358       Base::values_[2]*_rhs.Base::values_[0]-Base::values_[0]*_rhs.Base::values_[2],
00359       Base::values_[0]*_rhs.Base::values_[1]-Base::values_[1]*_rhs.Base::values_[0]);
00360   }
00361 #else
00362   ;
00363 #endif
00364 
00365 
00368   inline Scalar operator|(const vector_type& _rhs) const {
00369   Scalar p(0);
00370 #define expr(i) p += Base::values_[i] * _rhs.Base::values_[i];
00371   unroll(expr);
00372 #undef expr
00373     return p;
00374   }
00375 
00376 
00377 
00378 
00379 
00380   //------------------------------------------------------------ euclidean norm
00381 
00383 
00384 
00385   inline Scalar norm() const { return (Scalar)sqrt(sqrnorm()); }
00386   inline Scalar length() const { return norm(); } // OpenSG interface
00387 
00389   inline Scalar sqrnorm() const 
00390   {
00391 #if DIM==N
00392     Scalar s(0);
00393 #define expr(i) s += Base::values_[i] * Base::values_[i];
00394     unroll(expr);
00395 #undef expr
00396     return s;
00397 #else
00398 #define expr(i) Base::values_[i]*Base::values_[i]
00399     return (unroll_comb(expr, +));
00400 #undef expr
00401 #endif
00402   }
00404 
00408   inline vector_type& normalize() 
00409   {
00410     *this /= norm();
00411     return *this;
00412   }
00413   
00416   inline vector_type& normalize_cond() 
00417   {
00418     Scalar n = norm();
00419     if (n != (Scalar)0.0)
00420     {
00421       *this /= n;
00422     }
00423     return *this;
00424   }
00425 
00426 
00427   //------------------------------------------------------------ max, min, mean
00428 
00430   inline Scalar max() const 
00431   {
00432     Scalar m(Base::values_[0]);
00433     for(int i=1; i<DIM; ++i) if(Base::values_[i]>m) m=Base::values_[i];
00434     return m;
00435   }
00436 
00438   inline Scalar min() const 
00439   {
00440     Scalar m(Base::values_[0]);
00441     for(int i=1; i<DIM; ++i) if(Base::values_[i]<m) m=Base::values_[i];
00442     return m;
00443   }
00444 
00446   inline Scalar mean() const {
00447     Scalar m(Base::values_[0]);
00448     for(int i=1; i<DIM; ++i) m+=Base::values_[i];
00449     return m/Scalar(DIM);
00450   }
00451 
00453   inline vector_type minimize(const vector_type& _rhs) {
00454 #define expr(i) if (_rhs[i] < Base::values_[i]) Base::values_[i] = _rhs[i];
00455     unroll(expr);
00456 #undef expr
00457     return *this;
00458   }
00459 
00461   inline vector_type maximize(const vector_type& _rhs) {
00462 #define expr(i) if (_rhs[i] > Base::values_[i]) Base::values_[i] = _rhs[i];
00463     unroll(expr);
00464 #undef expr
00465     return *this;
00466   }
00467 
00469   inline vector_type min(const vector_type& _rhs) {
00470     return vector_type(*this).minimize(_rhs);
00471   }
00472 
00474   inline vector_type max(const vector_type& _rhs) {
00475     return vector_type(*this).maximize(_rhs);
00476   }
00477 
00478 
00479 
00480 
00481   //------------------------------------------------------------ misc functions
00482 
00484   template<typename Functor>
00485   inline vector_type apply(const Functor& _func) const {
00486     vector_type result;
00487 #define expr(i) result[i] = _func(Base::values_[i]);
00488     unroll(expr);
00489 #undef expr
00490     return result;
00491   }
00492 
00494   vector_type& vectorize(const Scalar& _s) {
00495 #define expr(i) Base::values_[i] = _s;
00496     unroll(expr);
00497 #undef expr
00498     return *this;
00499   }
00500 
00501 
00503   static vector_type vectorized(const Scalar& _s) {
00504     return vector_type().vectorize(_s);
00505   }
00506 
00507 
00509   bool operator<(const vector_type& _rhs) const {
00510 #define expr(i) if (Base::values_[i] != _rhs.Base::values_[i]) \
00511                    return (Base::values_[i] < _rhs.Base::values_[i]);
00512     unroll(expr);
00513 #undef expr
00514     return false;
00515    }
00516 };
00517 
00518 
00519 
00521 TEMPLATE_HEADER
00522 inline std::istream&
00523 operator>>(std::istream& is, VectorT<Scalar,DIM>& vec)
00524 {
00525 #define expr(i) is >> vec[i];
00526   unroll(expr);
00527 #undef expr
00528   return is;
00529 }
00530 
00531 
00533 TEMPLATE_HEADER
00534 inline std::ostream&
00535 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
00536 {
00537 #if DIM==N
00538   for(int i=0; i<N-1; ++i) os << vec[i] << " ";
00539   os << vec[N-1];
00540 #else
00541 #define expr(i) vec[i]
00542   os << unroll_comb(expr, << " " <<);
00543 #undef expr
00544 #endif
00545 
00546   return os;
00547 }
00548 
00549 
00550 // ----------------------------------------------------------------------------
00551 #endif // included by VectorT.hh
00552 //=============================================================================
src/OpenMesh/Core/Geometry/VectorT_inc.hh
