Main Page | Class Hierarchy | Class List | File List | Class Members

point_nd.h

00001 /*============================================================================ 00002 File: point_nd.h 00003 Purpose: 00004 Revision: $Id: point_nd.h,v 1.2 2002/05/13 21:07:45 philosophil Exp $ 00005 Created by: Philippe Lavoie (26 January, 1996) 00006 Modified by: Martin Schuerch 00007 00008 Copyright notice: 00009 Copyright (C) 1996-1999 Philippe Lavoie 00010 00011 This library is free software; you can redistribute it and/or 00012 modify it under the terms of the GNU Library General Public 00013 License as published by the Free Software Foundation; either 00014 version 2 of the License, or (at your option) any later version. 00015 00016 This library is distributed in the hope that it will be useful, 00017 but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00019 Library General Public License for more details. 00020 00021 You should have received a copy of the GNU Library General Public 00022 License along with this library; if not, write to the Free 00023 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00024 =============================================================================*/ 00025 #ifndef _Matrix_pointnD_h_ 00026 #define _Matrix_pointnD_h_ 00027 00028 #include "matrix_global.h" 00029 #include <memory.h> 00030 00031 00032 namespace PLib { 00033 00045 template <class T, int N> 00046 struct Point_nD { 00047 //only the specialications make sense, because this class should only be used for 00048 // (float,2), (float,3) (double,2) (double,3) 00049 }; 00050 00051 00052 template <> 00053 struct Point_nD<float,3> { 00054 typedef float T; 00055 T data[3] ; 00056 Point_nD() { x() = y() = z() = 0 ;} 00057 Point_nD(T a) { x() = y() = z() = a ;} 00058 Point_nD(T X, T Y, T Z) {x()=X ; y()=Y ; z()=Z ;} 00059 Point_nD(const Point_nD& a) { memcpy((void*)data,(void*)a.data,3*sizeof(T));} 00060 00061 inline T& x() { return data[0] ; } 00062 inline T& y() { return data[1] ; } 00063 inline T& z() { return data[2] ; } 00064 inline T x() const { return data[0] ; } 00065 inline T y() const { return data[1] ; } 00066 inline T z() const { return data[2] ; } 00067 00068 Point_nD& operator=(const Point_nD& v) { x()=v.x() ; y()=v.y() ; z()=v.z() ; return *this ;} ; 00069 Point_nD& operator+=(const Point_nD& v) {x()+=v.x() ; y()+= v.y() ; z()+=v.z() ; return *this;} ; 00070 Point_nD& operator-=(const Point_nD& v) {x()-=v.x() ; y()-= v.y() ; z()-=v.z() ; return *this;} ; 00071 Point_nD& operator*=(T v) {x()*=v ; y()*= v ; z()*= v; return *this;} ; 00072 Point_nD& operator/=(T v) {x()/=v ; y()/= v ; z()/= v ; return *this;} ; 00073 00074 Point_nD unitLength() const { T d = norm(); Point_nD<T,3> u(x()/d,y()/d,z()/d); return u; } 00075 T norm2() const { return data[0]*data[0] + data[1]*data[1] + data[2]*data[2]; } 00076 T norm() const { return sqrt( data[0]*data[0] + data[1]*data[1] + data[2]*data[2] ); } 00077 }; 00078 00079 00080 template <> 00081 struct Point_nD<double,3> { 00082 typedef double T; 00083 T data[3] ; 00084 Point_nD() { x() = y() = z() = 0 ;} 00085 Point_nD(T a) { x() = y() = z() = a ;} 00086 Point_nD(T X, T Y, T Z) {x()=X ; y()=Y ; z()=Z ;} 00087 Point_nD(const Point_nD& a) { memcpy((void*)data,(void*)a.data,3*sizeof(T));} 00088 00089 inline T& x() { return data[0] ; } 00090 inline T& y() { return data[1] ; } 00091 inline T& z() { return data[2] ; } 00092 inline T x() const { return data[0] ; } 00093 inline T y() const { return data[1] ; } 00094 inline T z() const { return data[2] ; } 00095 00096 Point_nD& operator=(const Point_nD& v) { x()=v.x() ; y()=v.y() ; z()=v.z() ; return *this ;} ; 00097 Point_nD& operator+=(const Point_nD& v) {x()+=v.x() ; y()+= v.y() ; z()+=v.z() ; return *this;} ; 00098 Point_nD& operator-=(const Point_nD& v) {x()-=v.x() ; y()-= v.y() ; z()-=v.z() ; return *this;} ; 00099 Point_nD& operator*=(T v) {x()*=v ; y()*= v ; z()*= v; return *this;} ; 00100 Point_nD& operator/=(T v) {x()/=v ; y()/= v ; z()/= v ; return *this;} ; 00101 00102 Point_nD unitLength() const { T d = norm(); Point_nD<T,3> u(x()/d,y()/d,z()/d); return u; } 00103 T norm2() const { return data[0]*data[0] + data[1]*data[1] + data[2]*data[2]; } 00104 T norm() const { return sqrt( data[0]*data[0] + data[1]*data[1] + data[2]*data[2] ); } 00105 }; 00106 00107 00108 template <> 00109 struct Point_nD<float,2> { 00110 typedef float T; 00111 T data[2] ; 00112 Point_nD() { x() = y() = 0 ;} 00113 Point_nD(T a) { x() = y() = a ;} 00114 Point_nD(T X, T Y) {x()=X ; y()=Y ; } 00115 Point_nD(const Point_nD<T,2>& a) { memcpy((void*)data,(void*)a.data,2*sizeof(T));} 00116 00117 inline T& x() { return data[0] ; } 00118 inline T& y() { return data[1] ; } 00119 inline T& z() { return dumbVar ; } 00120 inline T x() const { return data[0] ; } 00121 inline T y() const { return data[1] ; } 00122 inline T z() const { return T() ; } 00123 00124 Point_nD& operator=(const Point_nD& v) { x()=v.x() ; y()=v.y() ; return *this ;} ; 00125 Point_nD& operator+=(const Point_nD& v) {x()+=v.x() ; y()+= v.y() ; return *this;} ; 00126 Point_nD& operator-=(const Point_nD& v) {x()-=v.x() ; y()-= v.y() ; return *this;} ; 00127 Point_nD& operator*=(T v) {x()*=v ; y()*= v ; return *this;} ; 00128 Point_nD& operator/=(T v) {x()/=v ; y()/= v ; return *this;} ; 00129 00130 Point_nD unitLength() const { T d = norm(); Point_nD<T,2> u(x()/d,y()/d); return u;} 00131 T norm2() const { return data[0]*data[0] + data[1]*data[1]; } 00132 T norm() const { return sqrt( data[0]*data[0] + data[1]*data[1] ); } 00133 00134 protected: 00135 static T dumbVar ; 00136 }; 00137 00138 00139 template <> 00140 struct Point_nD<double,2> { 00141 typedef double T; 00142 T data[2] ; 00143 Point_nD() { x() = y() = 0 ;} 00144 Point_nD(T a) { x() = y() = a ;} 00145 Point_nD(T X, T Y) {x()=X ; y()=Y ; } 00146 Point_nD(const Point_nD<T,2>& a) { memcpy((void*)data,(void*)a.data,2*sizeof(T));} 00147 00148 inline T& x() { return data[0] ; } 00149 inline T& y() { return data[1] ; } 00150 inline T& z() { return dumbVar ; } 00151 inline T x() const { return data[0] ; } 00152 inline T y() const { return data[1] ; } 00153 inline T z() const { return T() ; } 00154 00155 Point_nD& operator=(const Point_nD& v) { x()=v.x() ; y()=v.y() ; return *this ;} ; 00156 Point_nD& operator+=(const Point_nD& v) {x()+=v.x() ; y()+= v.y() ; return *this;} ; 00157 Point_nD& operator-=(const Point_nD& v) {x()-=v.x() ; y()-= v.y() ; return *this;} ; 00158 Point_nD& operator*=(T v) {x()*=v ; y()*= v ; return *this;} ; 00159 Point_nD& operator/=(T v) {x()/=v ; y()/= v ; return *this;} ; 00160 00161 Point_nD unitLength() const { T d = norm(); Point_nD<T,2> u(x()/d,y()/d); return u;} 00162 T norm2() const { return data[0]*data[0] + data[1]*data[1]; } 00163 T norm() const { return sqrt( data[0]*data[0] + data[1]*data[1] ); } 00164 00165 protected: 00166 static T dumbVar ; 00167 }; 00168 00169 00170 00171 template <class T> 00172 inline int operator<(const Point_nD<T,3>& a, const Point_nD<T,3>& b) { 00173 return a.x()<b.x() || a.y()<b.y() || a.z()<b.z() ;} 00174 00175 template <class T> 00176 inline int operator>(const Point_nD<T,3>& a, const Point_nD<T,3>& b) { 00177 return a.x()>b.x() || a.y()>b.y() || a.z()>b.z() ;} 00178 00179 template <class T> 00180 inline int operator<=(const Point_nD<T,3>& a, const Point_nD<T,3>& b) { 00181 return a.x()<=b.x() || a.y()<=b.y() || a.z()<=b.z() ;} 00182 00183 template <class T> 00184 inline int operator>=(const Point_nD<T,3>& a, const Point_nD<T,3>& b) { 00185 return a.x()>=b.x() || a.y()>=b.y() || a.z()>=b.z() ;} 00186 00187 00188 00189 template <class T> 00190 inline int operator<(const Point_nD<T,2>& a, const Point_nD<T,2>& b) { 00191 return a.x()<b.x() || a.y()<b.y() ;} 00192 00193 template <class T> 00194 inline int operator>(const Point_nD<T,2>& a, const Point_nD<T,2>& b) { 00195 return a.x()>b.x() || a.y()>b.y() ;} 00196 00197 template <class T> 00198 inline int operator<=(const Point_nD<T,2>& a, const Point_nD<T,2>& b) { 00199 return a.x()<=b.x() || a.y()<=b.y() ;} 00200 00201 template <class T> 00202 inline int operator>=(const Point_nD<T,2>& a, const Point_nD<T,2>& b) { 00203 return a.x()>=b.x() || a.y()>=b.y() ;} 00204 00205 00206 00207 00208 00209 00210 00211 00212 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00213 Routine: operator* --- multiplies a point in 3D with a float 00214 Multiplies a point in 3D with a float 00215 Input: a --> the floating point value 00216 b --> the point in 3D 00217 Output: $ab$ 00218 Restrictions: 00219 author Philippe Lavoie (24 January 1997) 00220 Modified by: 00221 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00222 template <class T> 00223 inline Point_nD<T,3> operator*(const T a,const Point_nD<T,3>& b) { 00224 Point_nD<T,3> mul(b.x()*a,b.y()*a,b.z()*a) ; 00225 return mul ; 00226 } 00227 00228 inline Point_nD<float,3> operator*(const double a,const Point_nD<float,3>& b) { 00229 Point_nD<float,3> mul(b.x()*a,b.y()*a,b.z()*a) ; 00230 return mul ; 00231 } 00232 00233 template <class T> 00234 inline Point_nD<T,2> operator*(const T a,const Point_nD<T,2>& b) { 00235 Point_nD<T,2> mul(b.x()*a,b.y()*a) ; 00236 return mul ; 00237 } 00238 00239 inline Point_nD<float,2> operator*(const double a,const Point_nD<float,2>& b) { 00240 Point_nD<float,2> mul(b.x()*a,b.y()*a) ; 00241 return mul ; 00242 } 00243 00244 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00245 Routine: operator* --- multiplies a point in 3D with a float 00246 Multiplies a point in 3D with a float 00247 Input: a --> the floating point value 00248 b --> the point in 3D 00249 Output: $ab$ 00250 Restrictions: 00251 author Philippe Lavoie (24 January 1997) 00252 Modified by: 00253 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00254 template <class T> 00255 inline Point_nD<T,3> operator*(const Point_nD<T,3>& b,const T a) { 00256 Point_nD<T,3> mul(b.x()*a,b.y()*a,b.z()*a) ; 00257 return mul ; 00258 } 00259 00260 inline Point_nD<float,3> operator*(const Point_nD<float,3>& b,const double a) { 00261 Point_nD<float,3> mul(b.x()*a,b.y()*a,b.z()*a) ; 00262 return mul ; 00263 } 00264 00265 template <class T> 00266 inline Point_nD<T,2> operator*(const Point_nD<T,2>& b,const T a) { 00267 Point_nD<T,2> mul(b.x()*a,b.y()*a) ; 00268 return mul ; 00269 } 00270 00271 inline Point_nD<float,2> operator*(const Point_nD<float,2>& b,const double a) { 00272 Point_nD<float,2> mul(b.x()*a,b.y()*a) ; 00273 return mul ; 00274 } 00275 00276 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00277 Routine: operator/ --- Divide a point in 3D by a float 00278 Divide a point in 3D by a float. 00279 Input: a --> the point in 3D 00280 b --> the floating point value to divide with 00281 Output: $a/b$ 00282 Restrictions: 00283 author Philippe Lavoie (24 January 1997) 00284 Modified by: 00285 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00286 template <class T> 00287 inline Point_nD<T,3> operator/(const Point_nD<T,3>& a,const T b) { 00288 Point_nD<T,3> div(a.x()/b,a.y()/b,a.z()/b) ; 00289 return div ; 00290 } 00291 00292 inline Point_nD<float,3> operator/(const Point_nD<float,3>& a,const double b) { 00293 Point_nD<float,3> div(a.x()/b,a.y()/b,a.z()/b) ; 00294 return div ; 00295 } 00296 00297 template <class T> 00298 inline Point_nD<T,2> operator/(const Point_nD<T,2>& a,const T b) { 00299 Point_nD<T,2> div(a.x()/b,a.y()/b) ; 00300 return div ; 00301 } 00302 00303 inline Point_nD<float,2> operator/(const Point_nD<float,2>& a,const double b) { 00304 Point_nD<float,2> div(a.x()/b,a.y()/b) ; 00305 return div ; 00306 } 00307 00320 template <class T> 00321 inline T dot(const Point_nD<T,3>& a,const Point_nD<T,3>& b) { 00322 return a.x()*b.x() + a.y()*b.y() + a.z()*b.z() ; 00323 } 00324 00337 template <class T> 00338 inline T dot(const Point_nD<T,2>& a,const Point_nD<T,2>& b) { 00339 return a.x()*b.x() + a.y()*b.y() ; 00340 } 00341 00342 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00343 Routine: operator* --- the dot product of two points in 3D 00344 The dot product of two points in 3D 00345 Input: a --> the first point in 3D 00346 b --> the second point in 3D 00347 Output: $a.b$ 00348 Restrictions: 00349 author Philippe Lavoie (24 January 1997) 00350 Modified by: 00351 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00352 template <class T> 00353 inline T operator*(const Point_nD<T,3>& a,const Point_nD<T,3>& b) { 00354 return a.x()*b.x() + a.y()*b.y() + a.z()*b.z() ; 00355 } 00356 00357 template <class T> 00358 inline T operator*(const Point_nD<T,2>& a,const Point_nD<T,2>& b) { 00359 return a.x()*b.x() + a.y()*b.y() ; 00360 } 00361 00362 00363 00364 // Point3D definitions 00365 00366 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00367 Routine: operator+ --- the addition operator with points in 3D 00368 The addition operator with points in 3D 00369 Input: a --> the first point in 3D 00370 b --> the second point in 3D 00371 Output: $a+b$ 00372 Restrictions: 00373 author Philippe Lavoie (24 January 1997) 00374 Modified by: 00375 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00376 template <class T, int D> 00377 inline Point_nD<T,D> operator+(const Point_nD<T,D>& a,const Point_nD<T,D>& b) { 00378 Point_nD<T,D> sum(a) ; 00379 sum += b ; 00380 return sum ; 00381 } 00382 00383 00384 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00385 Routine: operator- --- the subtraction operator with points in 3D 00386 The subtraction operator with points in 3D 00387 Input: a --> the first point in 3D 00388 b --> the second point in 3D 00389 Output: $a-b$ 00390 Restrictions: 00391 author Philippe Lavoie (24 January 1997) 00392 Modified by: 00393 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00394 template <class T, int D> 00395 inline Point_nD<T,D> operator-(const Point_nD<T,D>& a,const Point_nD<T,D>& b) { 00396 Point_nD<T,D> diff(a) ; 00397 diff -= b ; 00398 return diff ; 00399 } 00400 00401 00402 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00403 Routine: operator== --- the equality operator with a float 00404 Finds if all the elements of the point in 3D are equal to $b$ 00405 Input: a --> the point in 3D 00406 b --> the floating point value 00407 Output: 1 if equal, 0 otherwise 00408 Restrictions: 00409 author Philippe Lavoie (24 January 1997) 00410 Modified by: 00411 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00412 template <class T> 00413 inline int operator==(const Point_nD<T,3>&a, float b) { 00414 if(a.x() == b && a.y() == b && a.z()==b) 00415 return 1 ; 00416 return 0 ; 00417 } 00418 00419 template <class T> 00420 inline int operator==(const Point_nD<T,2>&a, float b) { 00421 if(a.x() == b && a.y() == b ) 00422 return 1 ; 00423 return 0 ; 00424 } 00425 00426 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00427 Routine: operator!= --- the inequality operator between points in 3D 00428 The inequality operator between points in 3D. 00429 Input: a --> the first point in 3D 00430 b --> the second point in 3D 00431 Output: 1 if they are different, 0 otherwise 00432 Restrictions: 00433 author Philippe Lavoie (24 January 1997) 00434 Modified by: 00435 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00436 template <class T> 00437 inline int operator!=(const Point_nD<T,3>& a, const Point_nD<T,3>& b){ 00438 if(a.x() == b.x() && a.y() == b.y() && a.z() == b.z()) 00439 return 0 ; 00440 else 00441 return 1 ; 00442 } 00443 00444 template <class T> 00445 inline int operator!=(const Point_nD<T,2>& a, const Point_nD<T,2>& b){ 00446 if(a.x() == b.x() && a.y() == b.y() ) 00447 return 0 ; 00448 else 00449 return 1 ; 00450 } 00451 00452 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00453 Routine: operator== --- the equality operator between points in 3D 00454 The equality operator between points in 3D. 00455 Input: a --> the first point in 3D 00456 b --> the second point in 3D 00457 Output: 1 if they are equal, 0 otherwise 00458 Restrictions: 00459 author Philippe Lavoie (24 January 1997) 00460 Modified by: 00461 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00462 template <class T> 00463 inline int operator==(const Point_nD<T,3>& a, const Point_nD<T,3>& b){ 00464 if(a.x() == b.x() && a.y() == b.y() && a.z() == b.z()) 00465 return 1 ; 00466 else 00467 return 0 ; 00468 } 00469 00470 template <class T> 00471 inline int operator==(const Point_nD<T,2>& a, const Point_nD<T,2>& b){ 00472 if(a.x() == b.x() && a.y() == b.y() ) 00473 return 1 ; 00474 else 00475 return 0 ; 00476 } 00477 00478 00479 00480 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00481 Routine: norm2 --- the sum of the square of all the elements of a point 00482 The sum of the square of all the elements of a point or 00483 the length squared of the vector in 3D. 00484 Input: a --> the point 00485 Output: $a_x^2+a_y^2+a_z^2$ 00486 Restrictions: 00487 author Philippe Lavoie (24 January 1997) 00488 Modified by: 00489 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00490 template <class T,int N> 00491 inline double norm2(const Point_nD<T,N>& a){ 00492 double temp = 0 ; 00493 for(int i=N-1;i>=0;--i) 00494 temp += a.data[i]*a.data[i] ; 00495 return temp ; 00496 } 00497 00498 template <class T,int N> 00499 inline double norm(const Point_nD<T,N>& a) { return sqrt(norm2<T,N>(a)); } 00500 00501 00502 00503 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00504 Routine: angle --- Finds the angle between two points in 3D 00505 Finds the angle between two points in 3D 00506 Input: a --> the first point in 3D 00507 b --> the second point in 3D 00508 Output: The angle in radian between the two points 00509 Restrictions: 00510 author Philippe Lavoie (24 January 1997) 00511 Modified by: 00512 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00513 template <class T, int D> 00514 inline T angle(const Point_nD<T,D>& a,const Point_nD<T,D>& b) { 00515 if(b==0 || a==0 ) 00516 return 0 ; 00517 return acos(dot(a,b)/norm(a)/norm(b)) ; 00518 } 00519 00520 00521 template <class T> 00522 inline Point_nD<T,3> crossProduct(const Point_nD<T,3>& a, const Point_nD<T,3>& b){ 00523 Point_nD<T,3> prod ; 00524 prod.x() = a.y()*b.z() - a.z()*b.y() ; 00525 prod.y() = a.z()*b.x() - a.x()*b.z() ; 00526 prod.z() = a.x()*b.y() - a.y()*b.x() ; 00527 return prod ; 00528 } 00529 00530 00531 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00532 Routine: operator<< --- the output operator of a point in 3D 00533 to an ostream 00534 The output operator of a point in 3D to an ostream . 00535 Input: os --> the ostream 00536 point --> the point to output 00537 Output: the ostream with the point 00538 Restrictions: 00539 author Philippe Lavoie (24 January 1997) 00540 Modified by: 00541 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00542 template <class T> 00543 inline ostream& operator<<(ostream& os,const Point_nD<T,3>& point) 00544 { 00545 os << " " << point.x() << " " << point.y() << " " << point.z() << " " ; 00546 return os; 00547 } 00548 00549 template <class T> 00550 inline ostream& operator<<(ostream& os,const Point_nD<T,2>& point) 00551 { 00552 os << " " << point.x() << " " << point.y() << " " ; 00553 return os; 00554 } 00555 00556 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00557 Routine: operator>> --- the input operator from an istream 00558 Initialize a point in 3D from the input stream. 00559 Input: os --> the input stream 00560 point <-- the point to initialize 00561 Output: the istream without the point 00562 Restrictions: 00563 author Philippe Lavoie (24 January 1997) 00564 Modified by: 00565 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00566 template <class T> 00567 inline istream& operator>>(istream& os, Point_nD<T,3>& point){ 00568 float x,y,z ; 00569 os >> x >> y >> z ; 00570 point.x() = x ; 00571 point.y() = y ; 00572 point.z() = z ; 00573 return os ; 00574 } 00575 00576 template <class T> 00577 inline istream& operator>>(istream& os, Point_nD<T,2>& point){ 00578 float x,y ; 00579 os >> x >> y ; 00580 point.x() = x ; 00581 point.y() = y ; 00582 return os ; 00583 } 00584 00585 00586 template <class T> T minimum(T a, T b); 00587 template <class T> T maximum(T a, T b); 00588 00589 inline Point_nD<float,3> minimum(Point_nD<float,3> a, Point_nD<float,3> b){ 00590 Point_nD<float,3> m ; 00591 m.x() = minimum(a.x(),b.x()) ; 00592 m.y() = minimum(a.y(),b.y()) ; 00593 m.z() = minimum(a.z(),b.z()) ; 00594 return m ; 00595 } 00596 00597 inline Point_nD<double,3> minimum(Point_nD<double,3> a, Point_nD<double,3> b){ 00598 Point_nD<double,3> m ; 00599 m.x() = minimum(a.x(),b.x()) ; 00600 m.y() = minimum(a.y(),b.y()) ; 00601 m.z() = minimum(a.z(),b.z()) ; 00602 return m ; 00603 } 00604 00605 00606 inline Point_nD<float,2> minimum(Point_nD<float,2> a, Point_nD<float,2> b){ 00607 Point_nD<float,2> m ; 00608 m.x() = minimum(a.x(),b.x()) ; 00609 m.y() = minimum(a.y(),b.y()) ; 00610 return m ; 00611 } 00612 00613 00614 inline Point_nD<double,2> minimum(Point_nD<double,2> a, Point_nD<double,2> b){ 00615 Point_nD<double,2> m ; 00616 m.x() = minimum(a.x(),b.x()) ; 00617 m.y() = minimum(a.y(),b.y()) ; 00618 return m ; 00619 } 00620 00621 inline Point_nD<float,3> maximum(Point_nD<float,3> a,Point_nD<float,3> b){ 00622 Point_nD<float,3> m ; 00623 m.x() = maximum(a.x(),b.x()) ; 00624 m.y() = maximum(a.y(),b.y()) ; 00625 m.z() = maximum(a.z(),b.z()) ; 00626 return m ; 00627 } 00628 00629 inline Point_nD<double,3> maximum(Point_nD<double,3> a,Point_nD<double,3> b){ 00630 Point_nD<double,3> m ; 00631 m.x() = maximum(a.x(),b.x()) ; 00632 m.y() = maximum(a.y(),b.y()) ; 00633 m.z() = maximum(a.z(),b.z()) ; 00634 return m ; 00635 } 00636 00637 00638 inline Point_nD<float,2> maximum(Point_nD<float,2> a,Point_nD<float,2> b){ 00639 Point_nD<float,2> m ; 00640 m.x() = maximum(a.x(),b.x()) ; 00641 m.y() = maximum(a.y(),b.y()) ; 00642 return m ; 00643 } 00644 00645 inline Point_nD<double,2> maximum(Point_nD<double,2> a,Point_nD<double,2> b){ 00646 Point_nD<double,2> m ; 00647 m.x() = maximum(a.x(),b.x()) ; 00648 m.y() = maximum(a.y(),b.y()) ; 00649 return m ; 00650 } 00651 00652 00653 template <class T> 00654 inline Point_nD<T,3> minimumByRef(const Point_nD<T,3> &a,const Point_nD<T,3> &b){ 00655 Point_nD<T,3> m ; 00656 m.x() = minimum(a.x(),b.x()) ; 00657 m.y() = minimum(a.y(),b.y()) ; 00658 m.z() = minimum(a.z(),b.z()) ; 00659 return m ; 00660 } 00661 00662 00663 template <class T> 00664 inline Point_nD<T,2> minimumByRef(const Point_nD<T,2> &a,const Point_nD<T,2> &b){ 00665 Point_nD<T,2> m ; 00666 m.x() = minimum(a.x(),b.x()) ; 00667 m.y() = minimum(a.y(),b.y()) ; 00668 return m ; 00669 } 00670 00671 00672 template <class T> 00673 inline Point_nD<T,3> maximumByRef(const Point_nD<T,3> &a,const Point_nD<T,3> &b){ 00674 Point_nD<T,3> m ; 00675 m.x() = maximum(a.x(),b.x()) ; 00676 m.y() = maximum(a.y(),b.y()) ; 00677 m.z() = maximum(a.z(),b.z()) ; 00678 return m ; 00679 } 00680 00681 typedef Point_nD<float,3> Point3Df ; 00682 typedef Point_nD<double,3> Point3Dd ; 00683 00684 typedef Point_nD<float,2> Point2Df ; 00685 typedef Point_nD<double,2> Point2Dd ; 00686 00687 00688 00689 } // end namespace 00690 00691 typedef PLib::Point_nD<float,3> PlPoint3Df ; 00692 typedef PLib::Point_nD<double,3> PlPoint3Dd ; 00693 00694 typedef PLib::Point_nD<float,2> PlPoint2Df ; 00695 typedef PLib::Point_nD<double,2> PlPoint2Dd ; 00696 00697 00698 00699 #endif

Generated on Fri Aug 13 11:03:45 2004 for NURBS++ by doxygen 1.3.7