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 #ifndef LIGHTWEIGHT_GEOM_DATA_H
00029 #define LIGHTWEIGHT_GEOM_DATA_H
00030
00031 #include <mrpt/utils/utils_defs.h>
00032 #include <mrpt/utils/stl_extensions.h>
00033 #include <mrpt/math/utils.h>
00034
00035 namespace mrpt {
00036 namespace poses {
00037 class CPoseOrPoint;
00038 class CPoint2D;
00039 class CPoint3D;
00040 class CPose2D;
00041 class CPose3D;
00042 }
00043 namespace utils { class CStream; }
00044 }
00045
00046 namespace mrpt {
00047 namespace math {
00048 using namespace mrpt::utils;
00049
00050 struct TPoint2D;
00051 struct TPose2D;
00052 struct TPoint3D;
00053 struct TPose3D;
00054
00055
00056 #pragma pack(push,1)
00057
00058
00059
00060
00061
00062
00063 struct MRPTDLLIMPEXP TPoint2D {
00064
00065
00066
00067 double x;
00068
00069
00070
00071 double y;
00072
00073
00074
00075
00076 explicit TPoint2D(const TPose2D &p);
00077
00078
00079
00080
00081 explicit TPoint2D(const TPoint3D &p);
00082
00083
00084
00085
00086 explicit TPoint2D(const TPose3D &p);
00087
00088
00089
00090
00091 explicit TPoint2D(const mrpt::poses::CPoseOrPoint &p);
00092
00093
00094
00095
00096 TPoint2D(const mrpt::poses::CPoint2D &p);
00097
00098
00099
00100 inline TPoint2D(double xx,double yy):x(xx),y(yy) {}
00101
00102
00103
00104 inline TPoint2D() {}
00105
00106
00107
00108 inline double &operator[](size_t i) {
00109 return (&x)[i];
00110 }
00111
00112
00113
00114 inline const double &operator[](size_t i) const {
00115 return (&x)[i];
00116 }
00117
00118
00119
00120 void getAsVector(vector_double &v) const {
00121 v.resize(2);
00122 v[0]=x; v[1]=y;
00123 }
00124 };
00125
00126
00127
00128
00129
00130 struct MRPTDLLIMPEXP TPose2D {
00131
00132
00133
00134 double x;
00135
00136
00137
00138 double y;
00139
00140
00141
00142 double phi;
00143
00144
00145
00146
00147 TPose2D(const TPoint2D &p);
00148
00149
00150
00151
00152 explicit TPose2D(const TPoint3D &p);
00153
00154
00155
00156
00157 explicit TPose2D(const TPose3D &p);
00158
00159
00160
00161
00162 TPose2D(const mrpt::poses::CPose2D &p);
00163
00164
00165
00166 inline TPose2D(double xx,double yy,double pphi):x(xx),y(yy),phi(pphi) {}
00167
00168
00169
00170 inline TPose2D() {}
00171
00172
00173
00174 inline double &operator[](size_t i) {
00175 return (&x)[i];
00176 }
00177
00178
00179
00180 inline const double &operator[](size_t i) const {
00181 return (&x)[i];
00182 }
00183
00184
00185
00186 void getAsVector(vector_double &v) const {
00187 v.resize(3);
00188 v[0]=x; v[1]=y; v[2]=phi;
00189 }
00190 };
00191
00192
00193
00194
00195
00196 struct MRPTDLLIMPEXP TPoint3D {
00197
00198
00199
00200 double x;
00201
00202
00203
00204 double y;
00205
00206
00207
00208 double z;
00209
00210
00211
00212
00213 TPoint3D(const TPoint2D &p);
00214
00215
00216
00217
00218 explicit TPoint3D(const TPose2D &p);
00219
00220
00221
00222
00223 explicit TPoint3D(const TPose3D &p);
00224
00225
00226
00227
00228 TPoint3D(const mrpt::poses::CPoint3D &p);
00229
00230
00231
00232
00233 explicit TPoint3D(const mrpt::poses::CPose3D &p);
00234
00235
00236
00237 inline TPoint3D(double xx,double yy,double zz):x(xx),y(yy),z(zz) {}
00238
00239
00240
00241 inline TPoint3D() {}
00242
00243
00244
00245 inline double &operator[](size_t i) {
00246 return (&x)[i];
00247 }
00248
00249
00250
00251 inline const double &operator[](size_t i) const {
00252 return (&x)[i];
00253 }
00254
00255
00256
00257 inline double distanceTo(const TPoint3D &p) const {
00258 return sqrt(square(p.x-x)+square(p.y-y)+square(p.z-z));
00259 }
00260
00261
00262
00263 inline double sqrDistanceTo(const TPoint3D &p) const {
00264 return square(p.x-x)+square(p.y-y)+square(p.z-z);
00265 }
00266
00267
00268
00269 inline double norm() const {
00270 return sqrt(square(x)+square(y)+square(z));
00271 }
00272
00273
00274
00275 inline void operator *=(const double f) {
00276 x*=f;y*=f;z*=f;
00277 }
00278
00279
00280
00281 void getAsVector(vector_double &v) const {
00282 v.resize(3);
00283 v[0]=x; v[1]=y; v[2]=z;
00284 }
00285
00286
00287
00288 inline const TPoint3D &operator+=(const TPoint3D &p) {
00289 x+=p.x;
00290 y+=p.y;
00291 z+=p.z;
00292 return *this;
00293 }
00294
00295
00296
00297 inline const TPoint3D &operator-=(const TPoint3D &p) {
00298 x-=p.x;
00299 y-=p.y;
00300 z-=p.z;
00301 return *this;
00302 }
00303
00304
00305
00306 inline TPoint3D operator+(const TPoint3D &p) {
00307 return TPoint3D(x+p.x,y+p.y,z+p.z);
00308 }
00309
00310
00311
00312 inline TPoint3D operator-(const TPoint3D &p) {
00313 return TPoint3D(x-p.x,y-p.y,z-p.z);
00314 }
00315 };
00316
00317
00318
00319
00320
00321 struct MRPTDLLIMPEXP TPose3D {
00322
00323
00324
00325 double x;
00326
00327
00328
00329 double y;
00330
00331
00332
00333 double z;
00334
00335
00336
00337 double yaw;
00338
00339
00340
00341 double pitch;
00342
00343
00344
00345 double roll;
00346
00347
00348
00349
00350 TPose3D(const TPoint2D &p);
00351
00352
00353
00354
00355 TPose3D(const TPose2D &p);
00356
00357
00358
00359
00360 TPose3D(const TPoint3D &p);
00361
00362
00363
00364
00365 TPose3D(const mrpt::poses::CPose3D &p);
00366
00367
00368
00369 TPose3D(double _x,double _y,double _z,double _yaw,double _pitch,double _roll):x(_x),y(_y),z(_z),yaw(_yaw),pitch(_pitch),roll(_roll) {}
00370
00371
00372
00373 inline TPose3D() {}
00374
00375
00376
00377 inline double &operator[](size_t i) {
00378 return (&x)[i];
00379 }
00380
00381
00382
00383 inline const double &operator[](size_t i) const {
00384 return (&x)[i];
00385 }
00386
00387
00388
00389 double norm() const {
00390 return sqrt(square(x)+square(y)+square(z));
00391 }
00392
00393
00394
00395 void getAsVector(vector_double &v) const {
00396 v.resize(6);
00397 v[0]=x; v[1]=y; v[2]=z; v[3]=yaw; v[4]=pitch; v[5]=roll;
00398 }
00399 };
00400 #pragma pack(pop)
00401
00402
00403
00404 inline TPoint3D operator-(const TPoint3D &p1) {
00405 return TPoint3D(-p1.x,-p1.y,-p1.z);
00406 }
00407
00408
00409
00410 inline TPoint3D operator+(const TPoint3D &p1,const TPoint3D &p2) {
00411 return TPoint3D(p1.x+p2.x,p1.y+p2.y,p1.z+p2.z);
00412 }
00413
00414
00415
00416 inline TPoint3D operator-(const TPoint3D &p1,const TPoint3D &p2) {
00417 return TPoint3D(p1.x-p2.x,p1.y-p2.y,p1.z-p2.z);
00418 }
00419
00420
00421
00422 inline bool operator==(const TPoint2D &p1,const TPoint2D &p2) {
00423 return (p1.x==p2.x)&&(p1.y==p2.y);
00424 }
00425
00426
00427
00428 inline bool operator!=(const TPoint2D &p1,const TPoint2D &p2) {
00429 return (p1.x!=p2.x)||(p1.y!=p2.y);
00430 }
00431
00432
00433
00434 inline bool operator==(const TPoint3D &p1,const TPoint3D &p2) {
00435 return (p1.x==p2.x)&&(p1.y==p2.y)&&(p1.z==p2.z);
00436 }
00437
00438
00439
00440 inline bool operator!=(const TPoint3D &p1,const TPoint3D &p2) {
00441 return (p1.x!=p2.x)||(p1.y!=p2.y)||(p1.z!=p2.z);
00442 }
00443
00444
00445
00446 inline bool operator==(const TPose2D &p1,const TPose2D &p2) {
00447 return (p1.x==p2.x)&&(p1.y==p2.y)&&(mrpt::math::wrapTo2Pi(p1.phi)==mrpt::math::wrapTo2Pi(p2.phi));
00448 }
00449
00450
00451
00452 inline bool operator!=(const TPose2D &p1,const TPose2D &p2) {
00453 return (p1.x!=p2.x)||(p1.y!=p2.y)||(mrpt::math::wrapTo2Pi(p1.phi)!=mrpt::math::wrapTo2Pi(p2.phi));
00454 }
00455
00456
00457
00458 inline bool operator==(const TPose3D &p1,const TPose3D &p2) {
00459 return (p1.x==p2.x)&&(p1.y==p2.y)&&(p1.z==p2.z)&&(mrpt::math::wrapTo2Pi(p1.yaw)==mrpt::math::wrapTo2Pi(p2.yaw))&&(mrpt::math::wrapTo2Pi(p1.pitch)==mrpt::math::wrapTo2Pi(p2.pitch))&&(mrpt::math::wrapTo2Pi(p1.roll)==mrpt::math::wrapTo2Pi(p2.roll));
00460 }
00461
00462
00463
00464 inline bool operator!=(const TPose3D &p1,const TPose3D &p2) {
00465 return (p1.x!=p2.x)||(p1.y!=p2.y)||(p1.z!=p2.z)||(mrpt::math::wrapTo2Pi(p1.yaw)!=mrpt::math::wrapTo2Pi(p2.yaw))||(mrpt::math::wrapTo2Pi(p1.pitch)!=mrpt::math::wrapTo2Pi(p2.pitch))||(mrpt::math::wrapTo2Pi(p1.roll)!=mrpt::math::wrapTo2Pi(p2.roll));
00466 }
00467
00468 struct MRPTDLLIMPEXP TSegment3D;
00469 struct MRPTDLLIMPEXP TLine3D;
00470 class MRPTDLLIMPEXP TPolygon3D;
00471 struct MRPTDLLIMPEXP TObject3D;
00472
00473
00474 #pragma pack(push,1)
00475
00476
00477
00478
00479 struct MRPTDLLIMPEXP TSegment2D {
00480 public:
00481
00482
00483
00484 TPoint2D point1;
00485
00486
00487
00488 TPoint2D point2;
00489
00490
00491
00492 double length() const;
00493
00494
00495
00496 double distance(const TPoint2D &point) const;
00497
00498
00499
00500 bool contains(const TPoint2D &point) const;
00501
00502
00503
00504 inline TPoint2D &operator[](size_t i) {
00505 return (&point1)[i];
00506 }
00507
00508
00509
00510 inline const TPoint2D &operator[](size_t i) const {
00511 return (&point1)[i];
00512 }
00513
00514
00515
00516 void generate3DObject(TSegment3D &s) const;
00517
00518
00519
00520 inline void getCenter(TPoint2D &p) const {
00521 p.x=(point1.x+point2.x)/2;
00522 p.y=(point1.y+point2.y)/2;
00523 }
00524
00525
00526
00527 TSegment2D(const TPoint2D &p1,const TPoint2D &p2):point1(p1),point2(p2) {}
00528
00529
00530
00531 TSegment2D() {}
00532
00533
00534
00535 explicit TSegment2D(const TSegment3D &s);
00536 };
00537
00538
00539
00540
00541 struct MRPTDLLIMPEXP TSegment3D {
00542 public:
00543
00544
00545
00546 TPoint3D point1;
00547
00548
00549
00550 TPoint3D point2;
00551
00552
00553
00554 double length() const;
00555
00556
00557
00558 double distance(const TPoint3D &point) const;
00559
00560
00561
00562 bool contains(const TPoint3D &point) const;
00563
00564
00565
00566 inline TPoint3D &operator[](size_t i) {
00567 return (&point1)[i];
00568 }
00569
00570
00571
00572 inline const TPoint3D &operator[](size_t i) const {
00573 return (&point1)[i];
00574 }
00575
00576
00577
00578 inline void generate2DObject(TSegment2D &s) const {
00579 s=TSegment2D(*this);
00580 }
00581
00582
00583
00584 inline void getCenter(TPoint3D &p) const {
00585 p.x=(point1.x+point2.x)/2;
00586 p.y=(point1.y+point2.y)/2;
00587 p.z=(point1.z+point2.z)/2;
00588 }
00589
00590
00591
00592 TSegment3D(const TPoint3D &p1,const TPoint3D &p2):point1(p1),point2(p2) {}
00593
00594
00595
00596 TSegment3D() {}
00597
00598
00599
00600 TSegment3D(const TSegment2D &s):point1(s.point1),point2(s.point2) {}
00601 };
00602 #pragma pack(pop)
00603
00604
00605
00606
00607
00608 struct MRPTDLLIMPEXP TLine2D {
00609 public:
00610
00611
00612
00613 double coefs[3];
00614
00615
00616
00617 double evaluatePoint(const TPoint2D &point) const;
00618
00619
00620
00621 bool contains(const TPoint2D &point) const;
00622
00623
00624
00625 double distance(const TPoint2D &point) const;
00626
00627
00628
00629 void getNormalVector(double (&vector)[2]) const;
00630
00631
00632
00633 void unitarize();
00634
00635
00636
00637 inline void getUnitaryNormalVector(double (&vector)[2]) {
00638 unitarize();
00639 getNormalVector(vector);
00640 }
00641
00642
00643
00644 void getDirectorVector(double (&vector)[2]) const;
00645
00646
00647
00648 inline void getUnitaryDirectorVector(double (&vector)[2]) {
00649 unitarize();
00650 getDirectorVector(vector);
00651 }
00652
00653
00654
00655 void generate3DObject(TLine3D &l) const;
00656
00657
00658
00659
00660 void getAsPose2D(mrpt::poses::CPose2D &outPose) const;
00661
00662
00663
00664
00665
00666 void getAsPose2DForcingOrigin(const TPoint2D &origin,mrpt::poses::CPose2D &outPose) const;
00667
00668
00669
00670
00671 TLine2D(const TPoint2D &p1,const TPoint2D &p2) throw(std::logic_error);
00672
00673
00674
00675 explicit TLine2D(const TSegment2D &s);
00676
00677
00678
00679 TLine2D() {}
00680
00681
00682
00683 inline TLine2D(double A,double B,double C) {
00684 coefs[0]=A;
00685 coefs[1]=B;
00686 coefs[2]=C;
00687 }
00688
00689
00690
00691
00692 explicit TLine2D(const TLine3D &l);
00693 };
00694
00695
00696
00697
00698
00699 struct MRPTDLLIMPEXP TLine3D {
00700 public:
00701
00702
00703
00704 TPoint3D pBase;
00705
00706
00707
00708 double director[3];
00709
00710
00711
00712 bool contains(const TPoint3D &point) const;
00713
00714
00715
00716 double distance(const TPoint3D &point) const;
00717
00718
00719
00720 void unitarize();
00721
00722
00723
00724 inline void getDirectorVector(double (&vector)[3]) const {
00725 for (size_t i=0;i<3;i++) vector[i]=director[i];
00726 }
00727
00728
00729
00730 inline void getUnitaryDirectorVector(double (&vector)[3]) {
00731 unitarize();
00732 getDirectorVector(vector);
00733 }
00734
00735
00736
00737
00738 inline void generate2DObject(TLine2D &l) const {
00739 l=TLine2D(*this);
00740 }
00741
00742
00743
00744
00745 TLine3D(const TPoint3D &p1,const TPoint3D &p2) throw(std::logic_error);
00746
00747
00748
00749 explicit TLine3D(const TSegment3D &s);
00750
00751
00752
00753 TLine3D() {}
00754
00755
00756
00757 TLine3D(const TLine2D &l);
00758 };
00759
00760
00761
00762
00763
00764 struct MRPTDLLIMPEXP TPlane {
00765 public:
00766
00767
00768
00769 double coefs[4];
00770
00771
00772
00773 double evaluatePoint(const TPoint3D &point) const;
00774
00775
00776
00777 bool contains(const TPoint3D &point) const;
00778
00779
00780
00781 bool contains(const TSegment3D &segment) {
00782 return contains(segment.point1)&&contains(segment.point2);
00783 }
00784
00785
00786
00787 bool contains(const TLine3D &line) const;
00788
00789
00790
00791 double distance(const TPoint3D &point) const;
00792
00793
00794
00795 double distance(const TLine3D &line) const;
00796
00797
00798
00799 void getNormalVector(double (&vec)[3]) const;
00800
00801
00802
00803 void unitarize();
00804
00805
00806
00807 inline void getUnitaryNormalVector(double (&vec)[3]) {
00808 unitarize();
00809 getNormalVector(vec);
00810 }
00811
00812
00813
00814 void getAsPose3D(mrpt::poses::CPose3D &outPose);
00815
00816
00817
00818
00819 void getAsPose3DForcingOrigin(const TPoint3D &newOrigin,mrpt::poses::CPose3D &pose);
00820
00821
00822
00823
00824 TPlane(const TPoint3D &p1,const TPoint3D &p2,const TPoint3D &p3) throw(std::logic_error);
00825
00826
00827
00828
00829 TPlane(const TPoint3D &p1,const TLine3D &r2) throw(std::logic_error);
00830
00831
00832
00833
00834 TPlane(const TLine3D &r1,const TLine3D &r2) throw(std::logic_error);
00835
00836
00837
00838 TPlane() {}
00839
00840
00841
00842 inline TPlane(double A,double B,double C,double D) {
00843 coefs[0]=A;
00844 coefs[1]=B;
00845 coefs[2]=C;
00846 coefs[3]=D;
00847 }
00848
00849
00850
00851 inline TPlane(const double (&vec)[4]) {
00852 for (size_t i=0;i<4;i++) coefs[i]=vec[i];
00853 }
00854 };
00855
00856
00857
00858
00859
00860 class MRPTDLLIMPEXP TPolygon2D:public std::vector<TPoint2D> {
00861 public:
00862
00863
00864
00865 double distance(const TPoint2D &point) const;
00866
00867
00868
00869 bool contains(const TPoint2D &point) const;
00870
00871
00872
00873 void getAsSegmentList(std::vector<TSegment2D> &v) const;
00874
00875
00876
00877 void generate3DObject(TPolygon3D &p) const;
00878
00879
00880
00881 void getCenter(TPoint2D &p) const;
00882
00883
00884
00885 bool isConvex() const;
00886
00887
00888
00889
00890 void removeRepeatedVertices();
00891
00892
00893
00894
00895 void removeRedundantVertices();
00896
00897
00898
00899
00900 void getPlotData(std::vector<double> &x,std::vector<double> &y) const;
00901
00902
00903
00904 TPolygon2D():std::vector<TPoint2D>() {}
00905
00906
00907
00908 explicit TPolygon2D(size_t N):std::vector<TPoint2D>(N) {}
00909
00910
00911
00912 TPolygon2D(const std::vector<TPoint2D> &v):std::vector<TPoint2D>(v) {}
00913
00914
00915
00916 explicit TPolygon2D(const TPolygon3D &p);
00917
00918
00919
00920
00921 static void createRegularPolygon(size_t numEdges,double radius,TPolygon2D &poly);
00922
00923
00924
00925
00926 static inline void createRegularPolygon(size_t numEdges,double radius,TPolygon2D &poly,const mrpt::poses::CPose2D &pose);
00927 };
00928
00929
00930
00931
00932
00933 class MRPTDLLIMPEXP TPolygon3D:public std::vector<TPoint3D> {
00934 public:
00935
00936
00937
00938 double distance(const TPoint3D &point) const;
00939
00940
00941
00942 bool contains(const TPoint3D &point) const;
00943
00944
00945
00946 void getAsSegmentList(std::vector<TSegment3D> &v) const;
00947
00948
00949
00950 bool getPlane(TPlane &p) const;
00951
00952
00953
00954
00955 void getBestFittingPlane(TPlane &p) const;
00956
00957
00958
00959
00960 inline void generate2DObject(TPolygon2D &p) const {
00961 p=TPolygon2D(*this);
00962 }
00963
00964
00965
00966 void getCenter(TPoint3D &p) const;
00967
00968
00969
00970
00971 bool isSkew() const;
00972
00973
00974
00975 void removeRepeatedVertices();
00976
00977
00978
00979 void removeRedundantVertices();
00980
00981
00982
00983 TPolygon3D():std::vector<TPoint3D>() {}
00984
00985
00986
00987 explicit TPolygon3D(size_t N):std::vector<TPoint3D>(N) {}
00988
00989
00990
00991 TPolygon3D(const std::vector<TPoint3D> &v):std::vector<TPoint3D>(v) {}
00992
00993
00994
00995 TPolygon3D(const TPolygon2D &p);
00996
00997
00998
00999
01000 static void createRegularPolygon(size_t numEdges,double radius,TPolygon3D &poly);
01001
01002
01003
01004
01005 static inline void createRegularPolygon(size_t numEdges,double radius,TPolygon3D &poly,const mrpt::poses::CPose3D &pose);
01006 };
01007
01008
01009
01010
01011
01012 const unsigned char GEOMETRIC_TYPE_POINT=0;
01013
01014
01015
01016
01017 const unsigned char GEOMETRIC_TYPE_SEGMENT=1;
01018
01019
01020
01021
01022 const unsigned char GEOMETRIC_TYPE_LINE=2;
01023
01024
01025
01026
01027 const unsigned char GEOMETRIC_TYPE_POLYGON=3;
01028
01029
01030
01031
01032 const unsigned char GEOMETRIC_TYPE_PLANE=4;
01033
01034
01035
01036
01037 const unsigned char GEOMETRIC_TYPE_UNDEFINED=255;
01038
01039
01040
01041
01042
01043 #ifdef TOBJECTS_USE_UNIONS
01044 struct MRPTDLLIMPEXP TObject2D {
01045 private:
01046
01047
01048
01049 unsigned char type;
01050
01051
01052
01053 union {
01054 TPoint2D *point;
01055 TSegment2D *segment;
01056 TLine2D *line;
01057 TPolygon2D *polygon;
01058 } data;
01059
01060
01061
01062 void destroy() {
01063 switch(type) {
01064 case GEOMETRIC_TYPE_POINT:
01065 delete data.point;
01066 break;
01067 case GEOMETRIC_TYPE_SEGMENT:
01068 delete data.segment;
01069 break;
01070 case GEOMETRIC_TYPE_LINE:
01071 delete data.line;
01072 break;
01073 case GEOMETRIC_TYPE_POLYGON:
01074 delete data.polygon;
01075 break;
01076 }
01077 type=GEOMETRIC_TYPE_UNDEFINED;
01078 }
01079 public:
01080
01081
01082
01083 TObject2D(const TPoint2D &p):type(GEOMETRIC_TYPE_POINT) {
01084 data.point=new TPoint2D(p);
01085 }
01086
01087
01088
01089 TObject2D(const TSegment2D &s):type(GEOMETRIC_TYPE_SEGMENT) {
01090 data.segment=new TSegment2D(s);
01091 }
01092
01093
01094
01095 TObject2D(const TLine2D &r):type(GEOMETRIC_TYPE_LINE) {
01096 data.line=new TLine2D(r);
01097 }
01098
01099
01100
01101 TObject2D(const TPolygon2D &p):type(GEOMETRIC_TYPE_POLYGON) {
01102 data.polygon=new TPolygon2D(p);
01103 }
01104
01105
01106
01107 TObject2D():type(GEOMETRIC_TYPE_UNDEFINED) {}
01108
01109
01110
01111 ~TObject2D() {
01112 destroy();
01113 }
01114
01115
01116
01117 inline bool isPoint() const {
01118 return type==GEOMETRIC_TYPE_POINT;
01119 }
01120
01121
01122
01123 inline bool isSegment() const {
01124 return type==GEOMETRIC_TYPE_SEGMENT;
01125 }
01126
01127
01128
01129 inline bool isLine() const {
01130 return type==GEOMETRIC_TYPE_LINE;
01131 }
01132
01133
01134
01135 inline bool isPolygon() const {
01136 return type==GEOMETRIC_TYPE_POLYGON;
01137 }
01138
01139
01140
01141 inline unsigned char getType() const {
01142 return type;
01143 }
01144
01145
01146
01147 inline bool getPoint(TPoint2D &p) const {
01148 if (isPoint()) {
01149 p=*(data.point);
01150 return true;
01151 } else return false;
01152 }
01153
01154
01155
01156 inline bool getSegment(TSegment2D &s) const {
01157 if (isSegment()) {
01158 s=*(data.segment);
01159 return true;
01160 } else return false;
01161 }
01162
01163
01164
01165 inline bool getLine(TLine2D &r) const {
01166 if (isLine()) {
01167 r=*(data.line);
01168 return true;
01169 } else return false;
01170 }
01171
01172
01173
01174 inline bool getPolygon(TPolygon2D &p) const {
01175 if (isPolygon()) {
01176 p=*(data.polygon);
01177 return true;
01178 } else return false;
01179 }
01180
01181
01182
01183 void operator=(const TObject2D &obj) {
01184 if (this==&obj) return;
01185 destroy();
01186 switch (type=obj.type) {
01187 case GEOMETRIC_TYPE_POINT:
01188 data.point=new TPoint2D(*(obj.data.point));
01189 break;
01190 case GEOMETRIC_TYPE_SEGMENT:
01191 data.segment=new TSegment2D(*(obj.data.segment));
01192 break;
01193 case GEOMETRIC_TYPE_LINE:
01194 data.line=new TLine2D(*(obj.data.line));
01195 break;
01196 case GEOMETRIC_TYPE_POLYGON:
01197 data.polygon=new TPolygon2D(*(obj.data.polygon));
01198 break;
01199 }
01200 }
01201
01202
01203
01204 inline void operator=(const TPoint2D &p) {
01205 destroy();
01206 type=GEOMETRIC_TYPE_POINT;
01207 data.point=new TPoint2D(p);
01208 }
01209
01210
01211
01212 inline void operator=(const TSegment2D &s) {
01213 destroy();
01214 type=GEOMETRIC_TYPE_SEGMENT;
01215 data.segment=new TSegment2D(s);
01216 }
01217
01218
01219
01220 inline void operator=(const TLine2D &l) {
01221 destroy();
01222 type=GEOMETRIC_TYPE_LINE;
01223 data.line=new TLine2D(l);
01224 }
01225
01226
01227
01228 inline void operator=(const TPolygon2D &p) {
01229 destroy();
01230 type=GEOMETRIC_TYPE_POLYGON;
01231 data.polygon=new TPolygon2D(p);
01232 }
01233
01234
01235
01236 void generate3DObject(TObject3D &obj) const;
01237
01238
01239
01240 TObject2D(const TObject2D &obj):type(GEOMETRIC_TYPE_UNDEFINED) {
01241 operator=(obj);
01242 }
01243
01244
01245
01246 static void getPoints(const std::vector<TObject2D> &objs,std::vector<TPoint2D> &pnts);
01247
01248
01249
01250 static void getSegments(const std::vector<TObject2D> &objs,std::vector<TSegment2D> &sgms);
01251
01252
01253
01254 static void getLines(const std::vector<TObject2D> &objs,std::vector<TLine2D> &lins);
01255
01256
01257
01258 static void getPolygons(const std::vector<TObject2D> &objs,std::vector<TPolygon2D> &polys);
01259
01260
01261
01262 static void getPoints(const std::vector<TObject2D> &objs,std::vector<TPoint2D> &pnts,std::vector<TObject2D> &remainder);
01263
01264
01265
01266 static void getSegments(const std::vector<TObject2D> &objs,std::vector<TSegment2D> &sgms,std::vector<TObject2D> &remainder);
01267
01268
01269
01270 static void getLines(const std::vector<TObject2D> &objs,std::vector<TLine2D> &lins,std::vector<TObject2D> &remainder);
01271
01272
01273
01274 static void getPolygons(const std::vector<TObject2D> &objs,std::vector<TPolygon2D> &polys,std::vector<TObject2D> &remainder);
01275 };
01276
01277
01278
01279
01280 struct MRPTDLLIMPEXP TObject3D {
01281 private:
01282
01283
01284
01285 unsigned char type;
01286
01287
01288
01289 union {
01290 TPoint3D *point;
01291 TSegment3D *segment;
01292 TLine3D *line;
01293 TPolygon3D *polygon;
01294 TPlane *plane;
01295 } data;
01296
01297
01298
01299 void destroy() {
01300 switch (type) {
01301 case GEOMETRIC_TYPE_POINT:
01302 delete data.point;
01303 break;
01304 case GEOMETRIC_TYPE_SEGMENT:
01305 delete data.segment;
01306 break;
01307 case GEOMETRIC_TYPE_LINE:
01308 delete data.line;
01309 break;
01310 case GEOMETRIC_TYPE_POLYGON:
01311 delete data.polygon;
01312 break;
01313 case GEOMETRIC_TYPE_PLANE:
01314 delete data.plane;
01315 break;
01316 case GEOMETRIC_TYPE_UNDEFINED:
01317 break;
01318 default:
01319 THROW_EXCEPTION("Invalid TObject2D object");
01320 }
01321 type=GEOMETRIC_TYPE_UNDEFINED;
01322 }
01323 public:
01324
01325
01326
01327 TObject3D(const TPoint3D &p):type(GEOMETRIC_TYPE_POINT) {
01328 data.point=new TPoint3D(p);
01329 }
01330
01331
01332
01333 TObject3D(const TSegment3D &s):type(GEOMETRIC_TYPE_SEGMENT) {
01334 data.segment=new TSegment3D(s);
01335 }
01336
01337
01338
01339 TObject3D(const TLine3D &r):type(GEOMETRIC_TYPE_LINE) {
01340 data.line=new TLine3D(r);
01341 }
01342
01343
01344
01345 TObject3D(const TPolygon3D &p):type(GEOMETRIC_TYPE_POLYGON) {
01346 data.polygon=new TPolygon3D(p);
01347 }
01348
01349
01350
01351 TObject3D(const TPlane &p):type(GEOMETRIC_TYPE_PLANE) {
01352 data.plane=new TPlane(p);
01353 }
01354
01355
01356
01357 TObject3D():type(GEOMETRIC_TYPE_UNDEFINED) {}
01358
01359
01360
01361 ~TObject3D() {
01362 destroy();
01363 }
01364
01365
01366
01367 inline bool isPoint() const {
01368 return type==GEOMETRIC_TYPE_POINT;
01369 }
01370
01371
01372
01373 inline bool isSegment() const {
01374 return type==GEOMETRIC_TYPE_SEGMENT;
01375 }
01376
01377
01378
01379 inline bool isLine() const {
01380 return type==GEOMETRIC_TYPE_LINE;
01381 }
01382
01383
01384
01385 inline bool isPolygon() const {
01386 return type==GEOMETRIC_TYPE_POLYGON;
01387 }
01388
01389
01390
01391 inline bool isPlane() const {
01392 return type==GEOMETRIC_TYPE_PLANE;
01393 }
01394
01395
01396
01397 inline unsigned char getType() const {
01398 return type;
01399 }
01400
01401
01402
01403 inline bool getPoint(TPoint3D &p) const {
01404 if (isPoint()) {
01405 p=*(data.point);
01406 return true;
01407 } else return false;
01408 }
01409
01410
01411
01412 inline bool getSegment(TSegment3D &s) const {
01413 if (isSegment()) {
01414 s=*(data.segment);
01415 return true;
01416 } else return false;
01417 }
01418
01419
01420
01421 inline bool getLine(TLine3D &r) const {
01422 if (isLine()) {
01423 r=*(data.line);
01424 return true;
01425 } else return false;
01426 }
01427
01428
01429
01430 inline bool getPolygon(TPolygon3D &p) const {
01431 if (isPolygon()) {
01432 p=*(data.polygon);
01433 return true;
01434 } else return false;
01435 }
01436
01437
01438
01439 inline bool getPlane(TPlane &p) const {
01440 if (isPlane()) {
01441 p=*(data.plane);
01442 return true;
01443 } else return false;
01444 }
01445
01446
01447
01448 void operator=(const TObject3D &obj) {
01449 if (this==&obj) return;
01450 destroy();
01451 switch (type=obj.type) {
01452 case GEOMETRIC_TYPE_POINT:
01453 data.point=new TPoint3D(*(obj.data.point));
01454 break;
01455 case GEOMETRIC_TYPE_SEGMENT:
01456 data.segment=new TSegment3D(*(obj.data.segment));
01457 break;
01458 case GEOMETRIC_TYPE_LINE:
01459 data.line=new TLine3D(*(obj.data.line));
01460 break;
01461 case GEOMETRIC_TYPE_POLYGON:
01462 data.polygon=new TPolygon3D(*(obj.data.polygon));
01463 break;
01464 case GEOMETRIC_TYPE_PLANE:
01465 data.plane=new TPlane(*(obj.data.plane));
01466 break;
01467 case GEOMETRIC_TYPE_UNDEFINED:
01468 break;
01469 default:
01470 THROW_EXCEPTION("Invalid TObject3D object");
01471 }
01472 }
01473
01474
01475
01476 inline void operator=(const TPoint3D &p) {
01477 destroy();
01478 type=GEOMETRIC_TYPE_POINT;
01479 data.point=new TPoint3D(p);
01480 }
01481
01482
01483
01484 inline void operator=(const TSegment3D &s) {
01485 destroy();
01486 type=GEOMETRIC_TYPE_SEGMENT;
01487 data.segment=new TSegment3D(s);
01488 }
01489
01490
01491
01492 inline void operator=(const TLine3D &l) {
01493 destroy();
01494 type=GEOMETRIC_TYPE_LINE;
01495 data.line=new TLine3D(l);
01496 }
01497
01498
01499
01500 inline void operator=(const TPolygon3D &p) {
01501 destroy();
01502 type=GEOMETRIC_TYPE_POLYGON;
01503 data.polygon=new TPolygon3D(p);
01504 }
01505
01506
01507
01508 inline void operator=(const TPlane &p) {
01509 destroy();
01510 type=GEOMETRIC_TYPE_PLANE;
01511 data.plane=new TPlane(p);
01512 }
01513
01514
01515
01516
01517 inline void generate2DObject(TObject2D &obj) const {
01518 switch (type) {
01519 case GEOMETRIC_TYPE_POINT:
01520 obj=TPoint2D(*(data.point));
01521 break;
01522 case GEOMETRIC_TYPE_SEGMENT:
01523 obj=TSegment2D(*(data.segment));
01524 break;
01525 case GEOMETRIC_TYPE_LINE:
01526 obj=TLine2D(*(data.line));
01527 break;
01528 case GEOMETRIC_TYPE_POLYGON:
01529 obj=TPolygon2D(*(data.polygon));
01530 break;
01531 case GEOMETRIC_TYPE_PLANE:
01532 throw std::logic_error("Too many dimensions");
01533 default:
01534 obj=TObject2D();
01535 break;
01536 }
01537 }
01538
01539
01540
01541 TObject3D(const TObject3D &obj):type(GEOMETRIC_TYPE_UNDEFINED) {
01542 operator=(obj);
01543 }
01544
01545
01546
01547 static void getPoints(const std::vector<TObject3D> &objs,std::vector<TPoint3D> &pnts);
01548
01549
01550
01551 static void getSegments(const std::vector<TObject3D> &objs,std::vector<TSegment3D> &sgms);
01552
01553
01554
01555 static void getLines(const std::vector<TObject3D> &objs,std::vector<TLine3D> &lins);
01556
01557
01558
01559 static void getPlanes(const std::vector<TObject3D> &objs,std::vector<TPlane> &plns);
01560
01561
01562
01563 static void getPolygons(const std::vector<TObject3D> &objs,std::vector<TPolygon3D> &polys);
01564
01565
01566
01567 static void getPoints(const std::vector<TObject3D> &objs,std::vector<TPoint3D> &pnts,std::vector<TObject3D> &remainder);
01568
01569
01570
01571 static void getSegments(const std::vector<TObject3D> &objs,std::vector<TSegment3D> &sgms,std::vector<TObject3D> &remainder);
01572
01573
01574
01575 static void getLines(const std::vector<TObject3D> &objs,std::vector<TLine3D> &lins,std::vector<TObject3D> &remainder);
01576
01577
01578
01579 static void getPlanes(const std::vector<TObject3D> &objs,std::vector<TPlane> &plns,std::vector<TObject3D> &remainder);
01580
01581
01582
01583 static void getPolygons(const std::vector<TObject3D> &objs,std::vector<TPolygon3D> &polys,std::vector<TObject3D> &remainder);
01584 };
01585 #else
01586 struct MRPTDLLIMPEXP TObject2D {
01587 private:
01588
01589
01590
01591 unsigned char type;
01592
01593
01594
01595 struct {
01596 TPoint2D point;
01597 TSegment2D segment;
01598 TLine2D line;
01599 TPolygon2D *polygon;
01600 } data;
01601
01602
01603
01604 inline void destroy() {
01605 if (type==GEOMETRIC_TYPE_POLYGON) delete data.polygon;
01606 type=GEOMETRIC_TYPE_UNDEFINED;
01607 }
01608 public:
01609
01610
01611
01612 inline TObject2D(const TPoint2D &p):type(GEOMETRIC_TYPE_POINT) {
01613 data.point=p;
01614 }
01615
01616
01617
01618 inline TObject2D(const TSegment2D &s):type(GEOMETRIC_TYPE_SEGMENT) {
01619 data.segment=s;
01620 }
01621
01622
01623
01624 inline TObject2D(const TLine2D &r):type(GEOMETRIC_TYPE_LINE) {
01625 data.line=r;
01626 }
01627
01628
01629
01630 inline TObject2D(const TPolygon2D &p):type(GEOMETRIC_TYPE_POLYGON) {
01631 data.polygon=new TPolygon2D(p);
01632 }
01633
01634
01635
01636 TObject2D():type(GEOMETRIC_TYPE_UNDEFINED) {}
01637
01638
01639
01640 ~TObject2D() {
01641 destroy();
01642 }
01643
01644
01645
01646 inline bool isPoint() const {
01647 return type==GEOMETRIC_TYPE_POINT;
01648 }
01649
01650
01651
01652 inline bool isSegment() const {
01653 return type==GEOMETRIC_TYPE_SEGMENT;
01654 }
01655
01656
01657
01658 inline bool isLine() const {
01659 return type==GEOMETRIC_TYPE_LINE;
01660 }
01661
01662
01663
01664 inline bool isPolygon() const {
01665 return type==GEOMETRIC_TYPE_POLYGON;
01666 }
01667
01668
01669
01670 inline unsigned char getType() const {
01671 return type;
01672 }
01673
01674
01675
01676 inline bool getPoint(TPoint2D &p) const {
01677 if (isPoint()) {
01678 p=data.point;
01679 return true;
01680 } else return false;
01681 }
01682
01683
01684
01685 inline bool getSegment(TSegment2D &s) const {
01686 if (isSegment()) {
01687 s=data.segment;
01688 return true;
01689 } else return false;
01690 }
01691
01692
01693
01694 inline bool getLine(TLine2D &r) const {
01695 if (isLine()) {
01696 r=data.line;
01697 return true;
01698 } else return false;
01699 }
01700
01701
01702
01703 inline bool getPolygon(TPolygon2D &p) const {
01704 if (isPolygon()) {
01705 p=*(data.polygon);
01706 return true;
01707 } else return false;
01708 }
01709
01710
01711
01712 void operator=(const TObject2D &obj) {
01713 if (this==&obj) return;
01714 destroy();
01715 switch (type=obj.type) {
01716 case GEOMETRIC_TYPE_POINT:
01717 data.point=obj.data.point;
01718 break;
01719 case GEOMETRIC_TYPE_SEGMENT:
01720 data.segment=obj.data.segment;
01721 break;
01722 case GEOMETRIC_TYPE_LINE:
01723 data.line=obj.data.line;
01724 break;
01725 case GEOMETRIC_TYPE_POLYGON:
01726 data.polygon=new TPolygon2D(*(obj.data.polygon));
01727 break;
01728 }
01729 }
01730
01731
01732
01733 inline void operator=(const TPoint2D &p) {
01734 destroy();
01735 type=GEOMETRIC_TYPE_POINT;
01736 data.point=p;
01737 }
01738
01739
01740
01741 inline void operator=(const TSegment2D &s) {
01742 destroy();
01743 type=GEOMETRIC_TYPE_SEGMENT;
01744 data.segment=s;
01745 }
01746
01747
01748
01749 inline void operator=(const TLine2D &l) {
01750 destroy();
01751 type=GEOMETRIC_TYPE_LINE;
01752 data.line=l;
01753 }
01754
01755
01756
01757 inline void operator=(const TPolygon2D &p) {
01758 destroy();
01759 type=GEOMETRIC_TYPE_POLYGON;
01760 data.polygon=new TPolygon2D(p);
01761 }
01762
01763
01764
01765 void generate3DObject(TObject3D &obj) const;
01766
01767
01768
01769 TObject2D(const TObject2D &obj):type(GEOMETRIC_TYPE_UNDEFINED) {
01770 operator=(obj);
01771 }
01772
01773
01774
01775 static void getPoints(const std::vector<TObject2D> &objs,std::vector<TPoint2D> &pnts);
01776
01777
01778
01779 static void getSegments(const std::vector<TObject2D> &objs,std::vector<TSegment2D> &sgms);
01780
01781
01782
01783 static void getLines(const std::vector<TObject2D> &objs,std::vector<TLine2D> &lins);
01784
01785
01786
01787 static void getPolygons(const std::vector<TObject2D> &objs,std::vector<TPolygon2D> &polys);
01788
01789
01790
01791 static void getPoints(const std::vector<TObject2D> &objs,std::vector<TPoint2D> &pnts,std::vector<TObject2D> &remainder);
01792
01793
01794
01795 static void getSegments(const std::vector<TObject2D> &objs,std::vector<TSegment2D> &sgms,std::vector<TObject2D> &remainder);
01796
01797
01798
01799 static void getLines(const std::vector<TObject2D> &objs,std::vector<TLine2D> &lins,std::vector<TObject2D> &remainder);
01800
01801
01802
01803 static void getPolygons(const std::vector<TObject2D> &objs,std::vector<TPolygon2D> &polys,std::vector<TObject2D> &remainder);
01804 };
01805
01806
01807
01808
01809 struct MRPTDLLIMPEXP TObject3D {
01810 private:
01811
01812
01813
01814 unsigned char type;
01815
01816
01817
01818 struct {
01819 TPoint3D point;
01820 TSegment3D segment;
01821 TLine3D line;
01822 TPolygon3D *polygon;
01823 TPlane plane;
01824 } data;
01825
01826
01827
01828 void destroy() {
01829 if (type==GEOMETRIC_TYPE_POLYGON) delete data.polygon;
01830 type=GEOMETRIC_TYPE_UNDEFINED;
01831 }
01832 public:
01833
01834
01835
01836 TObject3D(const TPoint3D &p):type(GEOMETRIC_TYPE_POINT) {
01837 data.point=p;
01838 }
01839
01840
01841
01842 TObject3D(const TSegment3D &s):type(GEOMETRIC_TYPE_SEGMENT) {
01843 data.segment=s;
01844 }
01845
01846
01847
01848 TObject3D(const TLine3D &r):type(GEOMETRIC_TYPE_LINE) {
01849 data.line=r;
01850 }
01851
01852
01853
01854 TObject3D(const TPolygon3D &p):type(GEOMETRIC_TYPE_POLYGON) {
01855 data.polygon=new TPolygon3D(p);
01856 }
01857
01858
01859
01860 TObject3D(const TPlane &p):type(GEOMETRIC_TYPE_PLANE) {
01861 data.plane=p;
01862 }
01863
01864
01865
01866 TObject3D():type(GEOMETRIC_TYPE_UNDEFINED) {}
01867
01868
01869
01870 ~TObject3D() {
01871 destroy();
01872 }
01873
01874
01875
01876 inline bool isPoint() const {
01877 return type==GEOMETRIC_TYPE_POINT;
01878 }
01879
01880
01881
01882 inline bool isSegment() const {
01883 return type==GEOMETRIC_TYPE_SEGMENT;
01884 }
01885
01886
01887
01888 inline bool isLine() const {
01889 return type==GEOMETRIC_TYPE_LINE;
01890 }
01891
01892
01893
01894 inline bool isPolygon() const {
01895 return type==GEOMETRIC_TYPE_POLYGON;
01896 }
01897
01898
01899
01900 inline bool isPlane() const {
01901 return type==GEOMETRIC_TYPE_PLANE;
01902 }
01903
01904
01905
01906 inline unsigned char getType() const {
01907 return type;
01908 }
01909
01910
01911
01912 inline bool getPoint(TPoint3D &p) const {
01913 if (isPoint()) {
01914 p=data.point;
01915 return true;
01916 } else return false;
01917 }
01918
01919
01920
01921 inline bool getSegment(TSegment3D &s) const {
01922 if (isSegment()) {
01923 s=data.segment;
01924 return true;
01925 } else return false;
01926 }
01927
01928
01929
01930 inline bool getLine(TLine3D &r) const {
01931 if (isLine()) {
01932 r=data.line;
01933 return true;
01934 } else return false;
01935 }
01936
01937
01938
01939 inline bool getPolygon(TPolygon3D &p) const {
01940 if (isPolygon()) {
01941 p=*(data.polygon);
01942 return true;
01943 } else return false;
01944 }
01945
01946
01947
01948 inline bool getPlane(TPlane &p) const {
01949 if (isPlane()) {
01950 p=data.plane;
01951 return true;
01952 } else return false;
01953 }
01954
01955
01956
01957 void operator=(const TObject3D &obj) {
01958 if (this==&obj) return;
01959 destroy();
01960 switch (type=obj.type) {
01961 case GEOMETRIC_TYPE_POINT:
01962 data.point=obj.data.point;
01963 break;
01964 case GEOMETRIC_TYPE_SEGMENT:
01965 data.segment=obj.data.segment;
01966 break;
01967 case GEOMETRIC_TYPE_LINE:
01968 data.line=obj.data.line;
01969 break;
01970 case GEOMETRIC_TYPE_POLYGON:
01971 data.polygon=new TPolygon3D(*(obj.data.polygon));
01972 break;
01973 case GEOMETRIC_TYPE_PLANE:
01974 data.plane=obj.data.plane;
01975 break;
01976 case GEOMETRIC_TYPE_UNDEFINED:
01977 break;
01978 default:
01979 THROW_EXCEPTION("Invalid TObject3D object");
01980 }
01981 }
01982
01983
01984
01985 inline void operator=(const TPoint3D &p) {
01986 destroy();
01987 type=GEOMETRIC_TYPE_POINT;
01988 data.point=p;
01989 }
01990
01991
01992
01993 inline void operator=(const TSegment3D &s) {
01994 destroy();
01995 type=GEOMETRIC_TYPE_SEGMENT;
01996 data.segment=s;
01997 }
01998
01999
02000
02001 inline void operator=(const TLine3D &l) {
02002 destroy();
02003 type=GEOMETRIC_TYPE_LINE;
02004 data.line=l;
02005 }
02006
02007
02008
02009 inline void operator=(const TPolygon3D &p) {
02010 destroy();
02011 type=GEOMETRIC_TYPE_POLYGON;
02012 data.polygon=new TPolygon3D(p);
02013 }
02014
02015
02016
02017 inline void operator=(const TPlane &p) {
02018 destroy();
02019 type=GEOMETRIC_TYPE_PLANE;
02020 data.plane=p;
02021 }
02022
02023
02024
02025
02026 inline void generate2DObject(TObject2D &obj) const {
02027 switch (type) {
02028 case GEOMETRIC_TYPE_POINT:
02029 obj=TPoint2D(data.point);
02030 break;
02031 case GEOMETRIC_TYPE_SEGMENT:
02032 obj=TSegment2D(data.segment);
02033 break;
02034 case GEOMETRIC_TYPE_LINE:
02035 obj=TLine2D(data.line);
02036 break;
02037 case GEOMETRIC_TYPE_POLYGON:
02038 obj=TPolygon2D(*(data.polygon));
02039 break;
02040 case GEOMETRIC_TYPE_PLANE:
02041 throw std::logic_error("Too many dimensions");
02042 default:
02043 obj=TObject2D();
02044 break;
02045 }
02046 }
02047
02048
02049
02050 TObject3D(const TObject3D &obj):type(GEOMETRIC_TYPE_UNDEFINED) {
02051 operator=(obj);
02052 }
02053
02054
02055
02056 static void getPoints(const std::vector<TObject3D> &objs,std::vector<TPoint3D> &pnts);
02057
02058
02059
02060 static void getSegments(const std::vector<TObject3D> &objs,std::vector<TSegment3D> &sgms);
02061
02062
02063
02064 static void getLines(const std::vector<TObject3D> &objs,std::vector<TLine3D> &lins);
02065
02066
02067
02068 static void getPlanes(const std::vector<TObject3D> &objs,std::vector<TPlane> &plns);
02069
02070
02071
02072 static void getPolygons(const std::vector<TObject3D> &objs,std::vector<TPolygon3D> &polys);
02073
02074
02075
02076 static void getPoints(const std::vector<TObject3D> &objs,std::vector<TPoint3D> &pnts,std::vector<TObject3D> &remainder);
02077
02078
02079
02080 static void getSegments(const std::vector<TObject3D> &objs,std::vector<TSegment3D> &sgms,std::vector<TObject3D> &remainder);
02081
02082
02083
02084 static void getLines(const std::vector<TObject3D> &objs,std::vector<TLine3D> &lins,std::vector<TObject3D> &remainder);
02085
02086
02087
02088 static void getPlanes(const std::vector<TObject3D> &objs,std::vector<TPlane> &plns,std::vector<TObject3D> &remainder);
02089
02090
02091
02092 static void getPolygons(const std::vector<TObject3D> &objs,std::vector<TPolygon3D> &polys,std::vector<TObject3D> &remainder);
02093 };
02094
02095 #endif
02096
02097
02098
02099
02100 MRPTDLLIMPEXP mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in,mrpt::math::TPoint2D &o);
02101
02102
02103
02104 MRPTDLLIMPEXP mrpt::utils::CStream& operator<<(mrpt::utils::CStream& out,const mrpt::math::TPoint2D &o);
02105
02106
02107
02108
02109 MRPTDLLIMPEXP mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in,mrpt::math::TPoint3D &o);
02110
02111
02112
02113 MRPTDLLIMPEXP mrpt::utils::CStream& operator<<(mrpt::utils::CStream& out,const mrpt::math::TPoint3D &o);
02114
02115
02116
02117
02118 MRPTDLLIMPEXP mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in,mrpt::math::TPose2D &o);
02119
02120
02121
02122 MRPTDLLIMPEXP mrpt::utils::CStream& operator<<(mrpt::utils::CStream& out,const mrpt::math::TPose2D &o);
02123
02124
02125
02126
02127 MRPTDLLIMPEXP mrpt::utils::CStream& operator>>(mrpt::utils::CStream& in,mrpt::math::TPose3D &o);
02128
02129
02130
02131 MRPTDLLIMPEXP mrpt::utils::CStream& operator<<(mrpt::utils::CStream& out,const mrpt::math::TPose3D &o);
02132
02133
02134
02135
02136 inline mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TSegment2D &s) {
02137 return in>>s.point1>>s.point2;
02138 }
02139
02140
02141
02142 inline mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TSegment2D &s) {
02143 return out<<s.point1<<s.point2;
02144 }
02145
02146
02147
02148
02149 inline mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TLine2D &l) {
02150 return in>>l.coefs[0]>>l.coefs[1]>>l.coefs[2];
02151 }
02152
02153
02154
02155 inline mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TLine2D &l) {
02156 return out<<l.coefs[0]<<l.coefs[1]<<l.coefs[2];
02157 }
02158
02159
02160
02161
02162 MRPTDLLIMPEXP mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TObject2D &o);
02163
02164
02165
02166 MRPTDLLIMPEXP mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TObject2D &o);
02167
02168
02169
02170
02171 inline mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TSegment3D &s) {
02172 return in>>s.point1>>s.point2;
02173 }
02174
02175
02176
02177 inline mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TSegment3D &s) {
02178 return out<<s.point1<<s.point2;
02179 }
02180
02181
02182
02183
02184 inline mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TLine3D &l) {
02185 return in>>l.pBase>>l.director[0]>>l.director[1]>>l.director[2];
02186 }
02187
02188
02189
02190 inline mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TLine3D &l) {
02191 return out<<l.pBase<<l.director[0]<<l.director[1]<<l.director[2];
02192 }
02193
02194
02195
02196
02197 inline mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TPlane &p) {
02198 return in>>p.coefs[0]>>p.coefs[1]>>p.coefs[2]>>p.coefs[3];
02199 }
02200
02201
02202
02203 inline mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TPlane &p) {
02204 return out<<p.coefs[0]<<p.coefs[1]<<p.coefs[2]<<p.coefs[3];
02205 }
02206
02207
02208
02209
02210 MRPTDLLIMPEXP mrpt::utils::CStream &operator>>(mrpt::utils::CStream &in,mrpt::math::TObject3D &o);
02211
02212
02213
02214 MRPTDLLIMPEXP mrpt::utils::CStream &operator<<(mrpt::utils::CStream &out,const mrpt::math::TObject3D &o);
02215
02216 }
02217
02218 namespace utils
02219 {
02220 using namespace ::mrpt::math;
02221
02222
02223 MRPT_DECLARE_TTYPENAME(TPoint2D)
02224 MRPT_DECLARE_TTYPENAME(TPoint3D)
02225 MRPT_DECLARE_TTYPENAME(TPose2D)
02226 MRPT_DECLARE_TTYPENAME(TPose3D)
02227 MRPT_DECLARE_TTYPENAME(TSegment2D)
02228 MRPT_DECLARE_TTYPENAME(TLine2D)
02229 MRPT_DECLARE_TTYPENAME(TPolygon2D)
02230 MRPT_DECLARE_TTYPENAME(TObject2D)
02231 MRPT_DECLARE_TTYPENAME(TSegment3D)
02232 MRPT_DECLARE_TTYPENAME(TLine3D)
02233 MRPT_DECLARE_TTYPENAME(TPlane)
02234 MRPT_DECLARE_TTYPENAME(TPolygon3D)
02235 MRPT_DECLARE_TTYPENAME(TObject3D)
02236
02237 }
02238
02239 }
02240 #endif