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
#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
00048
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
00214
00215
00216
00217
00218
00219
00220
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
00246
00247
00248
00249
00250
00251
00252
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
00278
00279
00280
00281
00282
00283
00284
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
00344
00345
00346
00347
00348
00349
00350
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
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
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
00386
00387
00388
00389
00390
00391
00392
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
00404
00405
00406
00407
00408
00409
00410
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
00428
00429
00430
00431
00432
00433
00434
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
00454
00455
00456
00457
00458
00459
00460
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
00482
00483
00484
00485
00486
00487
00488
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
00505
00506
00507
00508
00509
00510
00511
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
00533
00534
00535
00536
00537
00538
00539
00540
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
00558
00559
00560
00561
00562
00563
00564
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 }
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