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 DYNAMIC_COVERAGE_HH
00026 #define DYNAMIC_COVERAGE_HH
00027
00028 #include "coverage.hh"
00029 #include "inline-macro.hh"
00030
00031 #include <list>
00032 #include <queue>
00033 #include <stack>
00034
00035 namespace GMap3d
00036 {
00037 class CDart;
00038 class CGMapBasic;
00039
00040
00047 class CTemplateDynamicCoverage0 : public CCoverage
00048 {
00049 private:
00050
00051
00052
00054 CDart* FSelf;
00055
00057 bool FDoContinue;
00058
00059
00060
00061 public:
00062
00063
00064
00066 CTemplateDynamicCoverage0(CGMapBasic* AGMap, const CDart* ADart);
00068 virtual ~CTemplateDynamicCoverage0();
00069
00070
00071
00072
00073
00074 void reinit();
00075 void operator++();
00076 CDart* operator++(int);
00077 bool cont();
00078 CDart* operator*();
00079 TOperationState prevOperationType();
00080 int type() const;
00081
00083 };
00084
00085
00091 template <int Ai>
00092 class CTemplateDynamicCoverage1 : public CCoverage
00093 {
00094 private:
00095
00096
00097
00099 CDart* FDart1;
00100
00102 bool FDoContinue;
00103
00105 bool FDart1Active;
00106
00107
00108
00109 public:
00110
00111
00112
00114 CTemplateDynamicCoverage1(CGMapBasic* AGMap, const CDart* ADart);
00116 virtual ~CTemplateDynamicCoverage1();
00117
00118
00119
00120
00121
00122
00123 void reinit();
00124 void operator++();
00125 CDart* operator++(int);
00126 bool cont();
00127 CDart* operator*();
00128 TOperationState prevOperationType();
00129 int type() const;
00130
00131
00132 };
00133
00134
00141 template <int Ai, int Aj>
00142 class CTemplateDynamicCoverage2a : public CCoverage
00143 {
00144 private:
00145
00146
00147
00149 CDart* FDart1;
00151 CDart* FDartCurrent;
00152
00157 bool FEven;
00158
00160 TOperationState FPrevOp;
00161
00162
00163
00164 public:
00165
00166
00167
00169 CTemplateDynamicCoverage2a(CGMapBasic* AGMap, const CDart* ADart);
00171 virtual ~CTemplateDynamicCoverage2a();
00172
00173
00174
00175
00176
00177
00178 void reinit();
00179 void operator++();
00180 CDart* operator++(int);
00181 bool cont();
00182 CDart* operator*();
00183 TOperationState prevOperationType();
00184 int type() const;
00185
00186
00187 };
00188
00189
00196 template <int Ai, int Aj>
00197 class CTemplateDynamicCoverage2b : public CCoverage
00198 {
00199 private:
00200
00201
00202
00204 CDart* FDart1;
00206 CDart* FDartCurrent;
00207
00217 bool FFirstDirection;
00218
00223 bool FNextTryAi;
00224
00226 TOperationState FPrevOp;
00227
00228
00229
00230 public:
00231
00232
00233
00235 CTemplateDynamicCoverage2b(CGMapBasic* AGMap, const CDart* ADart);
00237 virtual ~CTemplateDynamicCoverage2b();
00238
00239
00240
00241
00242
00243
00244 void reinit();
00245 void operator++();
00246 CDart* operator++(int);
00247 bool cont();
00248 CDart* operator*();
00249 TOperationState prevOperationType();
00250 int type() const;
00251
00252
00253 };
00254
00255
00262 template <int Ai, int Aj, int Ak>
00263 class CTemplateDynamicCoverage3a : public CCoverage
00264 {
00265 private:
00266
00267
00268
00270 CTemplateDynamicCoverage2b<Ai,Aj> FIt;
00271
00273 bool FAkExist;
00274
00276 bool FFirstBorder;
00277
00279 bool FPrevAk;
00280
00282 TOperationState FPrevOp;
00283
00284
00285
00286 public:
00287
00288
00289
00291 CTemplateDynamicCoverage3a(CGMapBasic* AGMap, const CDart* ADart);
00293 virtual ~CTemplateDynamicCoverage3a();
00294
00295
00296
00297
00298
00299
00300 void reinit();
00301 void operator++();
00302 CDart* operator++(int);
00303 bool cont();
00304 CDart* operator*();
00305 TOperationState prevOperationType();
00306 int type() const;
00307
00308
00309 };
00310
00311
00319 template <int Ai, int Aj, int Ak>
00320 class CTemplateBasicDynamicCoverage3b : public CCoverage
00321 {
00322 private:
00323
00324
00325
00327 CDart* FDartCurrent;
00328
00330 int FMarkNumber;
00331
00333 std::queue<CDart*> FToTreat;
00334
00336 TOperationState FPrevOp;
00337
00338
00339
00340 public:
00341
00342
00343
00345 CTemplateBasicDynamicCoverage3b(CGMapBasic* AGMap,
00346 const CDart* ADart, int AMarkNumber);
00348 virtual ~CTemplateBasicDynamicCoverage3b();
00349
00350
00351
00352
00353
00354
00355 void reinit();
00356 void operator++();
00357 CDart* operator++(int);
00358 bool cont();
00359 CDart* operator*();
00360 TOperationState prevOperationType();
00361 int type() const;
00362
00363
00364 };
00365
00366
00374 class CTemplateBasicDynamicCoverage4 : public CCoverage
00375 {
00376 private:
00377
00378
00379
00381 CDart* FDartCurrent;
00382
00384 int FMarkNumber;
00385
00387 std::queue<CDart*> FToTreat;
00388
00390 TOperationState FPrevOp;
00391
00392
00393
00394 public:
00395
00396
00397
00399 CTemplateBasicDynamicCoverage4(CGMapBasic* AGMap, const CDart* ADart,
00400 int AMarkNumber);
00402 virtual ~CTemplateBasicDynamicCoverage4();
00403
00404
00405
00406
00407
00408
00409 void reinit();
00410 void operator++();
00411 CDart* operator++(int);
00412 bool cont();
00413 CDart* operator*();
00414 TOperationState prevOperationType();
00415 int type() const;
00416
00417
00418 };
00419
00420
00427 template <int Ai, int Aj, int Ak>
00428 class CTemplateDynamicCoverage3b : public CCoverage
00429 {
00430 private:
00431
00432
00433
00435 CDart* FDart1;
00436
00438 int FMarkNumber;
00439
00441 CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>* FIt;
00442
00443
00444
00445 public:
00446
00447
00448
00450 CTemplateDynamicCoverage3b(CGMapBasic* AGMap, const CDart* ADart);
00452 virtual ~CTemplateDynamicCoverage3b();
00453
00454
00455
00456
00457
00458
00459 void reinit();
00460 void operator++();
00461 CDart* operator++(int);
00462 bool cont();
00463 CDart* operator*();
00464 TOperationState prevOperationType();
00465 int type() const;
00466
00467
00468 };
00469
00470
00477 class CTemplateDynamicCoverage4 : public CCoverage
00478 {
00479 private:
00480
00481
00482
00484 CDart* FDart1;
00485
00487 int FMarkNumber;
00488
00490 CTemplateBasicDynamicCoverage4* FIt;
00491
00492
00493
00494 public:
00495
00496
00497
00499 CTemplateDynamicCoverage4(CGMapBasic* AGMap, const CDart* ADart);
00501 virtual ~CTemplateDynamicCoverage4();
00502
00503
00504
00505
00506
00507
00508 void reinit();
00509 void operator++();
00510 CDart* operator++(int);
00511 bool cont();
00512 CDart* operator*();
00513 TOperationState prevOperationType();
00514 int type() const;
00515
00516
00517 };
00518
00519
00529 template <int Ai, int Aj, int Ak>
00530 class CTemplateMultiDynamicCoverage3b : public CCoverage
00531 {
00532 private:
00534
00535
00537 int FMarkNumber;
00538
00540 CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>* FIt1;
00541
00543 std::list<CDart*> FAllCoverDarts;
00544
00546 std::list<CDart*>::iterator FIt2;
00547
00548
00549
00550 public:
00551
00552
00553
00555 CTemplateMultiDynamicCoverage3b(CGMapBasic* AGMap, const CDart* ADart);
00557 virtual ~CTemplateMultiDynamicCoverage3b();
00558
00559
00560
00561
00562
00563
00564 void reinit();
00565 void operator++();
00566 CDart* operator++(int);
00567 bool cont();
00568 CDart* operator*();
00569 TOperationState prevOperationType();
00570 int type() const;
00571
00572
00573 };
00574
00575
00585 class CTemplateMultiDynamicCoverage4 : public CCoverage
00586 {
00587 private:
00588
00589
00590
00592 int FMarkNumber;
00593
00595 CTemplateBasicDynamicCoverage4* FIt1;
00596
00598 std::list<CDart*> FAllCoverDarts;
00599
00601 std::list<CDart*>::iterator FIt2;
00602
00603
00604
00605 public:
00606
00607
00608
00610 CTemplateMultiDynamicCoverage4(CGMapBasic* AGMap, const CDart* ADart);
00612 virtual ~CTemplateMultiDynamicCoverage4();
00613
00614
00615
00616
00617
00618
00619 void reinit();
00620 void operator++();
00621 CDart* operator++(int);
00622 bool cont();
00623 CDart* operator*();
00624 TOperationState prevOperationType();
00625 int type() const;
00626
00627
00628 };
00629
00630
00636 class CDynamicCoverageAll : public CCoverage
00637 {
00638 private:
00639
00640
00641
00643 CDart* FCurrent;
00644
00645
00646
00647 public:
00648
00649
00650
00652 CDynamicCoverageAll(CGMapBasic* AGMap);
00654 virtual ~CDynamicCoverageAll();
00655
00656
00657
00658
00659
00660
00661 void reinit();
00662 void operator++();
00663 CDart* operator++(int);
00664 bool cont();
00665 CDart* operator*();
00666 TOperationState prevOperationType();
00667 int type() const;
00668
00669
00670 };
00671
00672
00679 class CBasicBorderCoverage : public CCoverage
00680 {
00681 private:
00682
00683
00684
00686 CDart* FCurrentDart;
00687
00689 int FMarkNumber;
00690
00692 int FBorderDim;
00693
00695 std::stack<CDart*> FToTreat;
00696
00698 TOperationState FPrevOp;
00699
00700
00701
00702 public:
00703
00704
00705
00707 CBasicBorderCoverage(CGMapBasic* AGMap, const CDart* ADart, int, int);
00709 virtual ~CBasicBorderCoverage();
00710
00711
00712
00713
00714
00715
00716 void reinit();
00717 void operator++();
00718 CDart* operator++(int);
00719 bool cont();
00720 CDart* operator*();
00721 TOperationState prevOperationType();
00722 int type() const;
00723
00724
00725 };
00726
00727
00733 class CDynamicBorderCoverage : public CCoverage
00734 {
00735 private:
00736
00737
00738
00740 CDart* FDart1;
00741
00743 int FBorderDim;
00744
00746 int FMarkNumber;
00747
00749 CBasicBorderCoverage* FIt;
00750
00751
00752
00753 public:
00754
00755
00756
00758 CDynamicBorderCoverage(CGMapBasic* AGMap, const CDart* ADart, int);
00760 virtual ~CDynamicBorderCoverage();
00761
00762
00763
00764
00765
00766
00767 void reinit();
00768 void operator++();
00769 CDart* operator++(int);
00770 bool cont();
00771 CDart* operator*();
00772 TOperationState prevOperationType();
00773 int type() const;
00774
00775
00776 };
00777
00778
00779
00780
00781
00782 typedef CTemplateDynamicCoverage0 CDynamicCoverageSelf;
00783
00784 typedef CTemplateDynamicCoverage1<0> CDynamicCoverage0;
00785 typedef CTemplateDynamicCoverage1<1> CDynamicCoverage1;
00786 typedef CTemplateDynamicCoverage1<2> CDynamicCoverage2;
00787 typedef CTemplateDynamicCoverage1<3> CDynamicCoverage3;
00788
00789 typedef CTemplateDynamicCoverage2a<0,2> CDynamicCoverage02;
00790 typedef CTemplateDynamicCoverage2a<0,3> CDynamicCoverage03;
00791 typedef CTemplateDynamicCoverage2a<1,3> CDynamicCoverage13;
00792
00793 typedef CTemplateDynamicCoverage2b<0,1> CDynamicCoverage01;
00794 typedef CTemplateDynamicCoverage2b<1,2> CDynamicCoverage12;
00795 typedef CTemplateDynamicCoverage2b<2,3> CDynamicCoverage23;
00796
00797 typedef CTemplateDynamicCoverage3a<0,1,3> CDynamicCoverage013;
00798 typedef CTemplateDynamicCoverage3a<2,3,0> CDynamicCoverage023;
00799
00800 typedef CTemplateDynamicCoverage3b<0,1,2> CDynamicCoverage012;
00801 typedef CTemplateDynamicCoverage3b<1,2,3> CDynamicCoverage123;
00802
00803 typedef CTemplateDynamicCoverage4 CDynamicCoverage0123;
00804
00806 typedef CDynamicCoverage123 CDynamicCoverageVertex;
00807 typedef CDynamicCoverage023 CDynamicCoverageEdge;
00808 typedef CDynamicCoverage013 CDynamicCoverageFace;
00809 typedef CDynamicCoverage012 CDynamicCoverageVolume;
00810 typedef CDynamicCoverage0123 CDynamicCoverageCC;
00811
00814 typedef CTemplateBasicDynamicCoverage3b<0,1,2> CBasicDynamicCoverage012;
00815 typedef CTemplateBasicDynamicCoverage3b<1,2,3> CBasicDynamicCoverage123;
00816 typedef CTemplateBasicDynamicCoverage4 CBasicDynamicCoverage0123;
00817
00818 typedef CBasicDynamicCoverage012 CBasicDynamicCoverageVolume;
00819 typedef CBasicDynamicCoverage123 CBasicDynamicCoverageVertex;
00820 typedef CBasicDynamicCoverage0123 CBasicDynamicCoverageCC;
00821
00825 typedef CTemplateMultiDynamicCoverage3b<0,1,2> CMultiDynamicCoverage012;
00826 typedef CTemplateMultiDynamicCoverage3b<1,2,3> CMultiDynamicCoverage123;
00827 typedef CTemplateMultiDynamicCoverage4 CMultiDynamicCoverage0123;
00828
00829 typedef CMultiDynamicCoverage012 CMultiDynamicCoverageVolume;
00830 typedef CMultiDynamicCoverage123 CMultiDynamicCoverageVertex;
00831 typedef CMultiDynamicCoverage0123 CMultiDynamicCoverageCC;
00832
00833
00834
00835 }
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846 #include "g-map-basic.hh"
00847 #include "dart.hh"
00848
00849 #include <cassert>
00850
00851 namespace GMap3d
00852 {
00853
00854
00855
00856 inline
00857 void CTemplateDynamicCoverage0::reinit()
00858 {
00859 FDoContinue = true;
00860 }
00861
00862 inline
00863 int CTemplateDynamicCoverage0::type() const
00864 {
00865 return COVERAGE0;
00866 }
00867
00868 inline
00869 CTemplateDynamicCoverage0::CTemplateDynamicCoverage0(CGMapBasic* AGMap,
00870 const CDart* ADart1) :
00871 CCoverage(AGMap),
00872 FSelf ((CDart*) ADart1)
00873 {
00874 reinit();
00875 }
00876
00877 inline
00878 CTemplateDynamicCoverage0::~CTemplateDynamicCoverage0()
00879 {
00880 }
00881
00882 inline
00883 bool CTemplateDynamicCoverage0::cont()
00884 {
00885 return FDoContinue;
00886 }
00887
00888 inline
00889 void CTemplateDynamicCoverage0::operator ++()
00890 {
00891 assert(cont());
00892
00893 FDoContinue = false;
00894 }
00895
00896 inline
00897 CDart* CTemplateDynamicCoverage0::operator*()
00898 {
00899 assert(cont());
00900
00901 return FSelf;
00902 }
00903
00904 inline
00905 CDart* CTemplateDynamicCoverage0::operator++(int)
00906 {
00907 CDart* tmp = operator*();
00908
00909 operator++();
00910 return tmp;
00911 }
00912
00913 inline
00914 TOperationState CTemplateDynamicCoverage0::prevOperationType()
00915 {
00916 return FDoContinue ? OP_NONE : OP_END;
00917 }
00918
00919
00920
00921 template <int Ai>
00922 inline
00923 void CTemplateDynamicCoverage1<Ai>::reinit()
00924 {
00925 FDoContinue = true;
00926 FDart1Active = true;
00927 }
00928
00929 template <int Ai>
00930 inline
00931 CTemplateDynamicCoverage1<Ai>::CTemplateDynamicCoverage1(CGMapBasic* AGMap,
00932 const CDart* ADart1) :
00933 CCoverage(AGMap),
00934 FDart1 ((CDart*) ADart1)
00935 {
00936 reinit();
00937 }
00938
00939 template <int Ai>
00940 inline
00941 CTemplateDynamicCoverage1<Ai>::~CTemplateDynamicCoverage1()
00942 {
00943 }
00944
00945 template <int Ai>
00946 inline
00947 bool CTemplateDynamicCoverage1<Ai>::cont()
00948 {
00949 return FDoContinue;
00950 }
00951
00952 template <int Ai>
00953 inline
00954 void CTemplateDynamicCoverage1<Ai>::operator++()
00955 {
00956 assert(cont());
00957
00958 if (! FDart1Active || FMap->isFree(FDart1, Ai))
00959 FDoContinue = false;
00960
00961 FDart1Active = false;
00962 }
00963
00964 template <int Ai>
00965 inline
00966 CDart* CTemplateDynamicCoverage1<Ai>::operator*()
00967 {
00968 assert(cont());
00969
00970 if (FDart1Active)
00971 return FDart1;
00972 else
00973 return FMap->alpha(FDart1, Ai);
00974 }
00975
00976 template <int Ai>
00977 inline
00978 CDart* CTemplateDynamicCoverage1<Ai>::operator++(int)
00979 {
00980 CDart* tmp = operator*();
00981
00982 operator++();
00983 return tmp;
00984 }
00985
00986 template <int Ai>
00987 inline
00988 TOperationState CTemplateDynamicCoverage1<Ai>::prevOperationType()
00989 {
00990 if (FDoContinue)
00991 return FDart1Active ? OP_NONE : OP_ALPHAI;
00992 else
00993 return OP_END;
00994 }
00995
00996 template <int Ai>
00997 inline
00998 int CTemplateDynamicCoverage1<Ai>::type() const
00999 {
01000 return COVERAGE1;
01001 }
01002
01003
01004
01005 template <int Ai, int Aj>
01006 inline
01007 void CTemplateDynamicCoverage2a<Ai,Aj>::reinit()
01008 {
01009 FDartCurrent = FDart1;
01010 FEven = true;
01011 FPrevOp = OP_NONE;
01012 }
01013
01014 template <int Ai, int Aj>
01015 inline
01016 CTemplateDynamicCoverage2a<Ai,Aj>::
01017 CTemplateDynamicCoverage2a(CGMapBasic* AGMap, const CDart* ADart1) :
01018 CCoverage(AGMap),
01019 FDart1 ((CDart*) ADart1)
01020 {
01021 reinit();
01022 }
01023
01024 template <int Ai, int Aj>
01025 inline
01026 CTemplateDynamicCoverage2a<Ai,Aj>::~CTemplateDynamicCoverage2a()
01027 {
01028 }
01029
01030 template <int Ai, int Aj>
01031 inline
01032 bool CTemplateDynamicCoverage2a<Ai,Aj>::cont()
01033 {
01034 return FPrevOp != OP_END;
01035 }
01036
01037 template <int Ai, int Aj>
01038 inline
01039 void CTemplateDynamicCoverage2a<Ai,Aj>::operator++()
01040 {
01041 assert(cont());
01042
01043 if (FEven)
01044 {
01045 if (FMap->isFree(FDartCurrent, Ai))
01046 {
01047 if (FMap->isFree(FDartCurrent, Aj))
01048 FPrevOp = OP_END;
01049 else
01050 {
01051 FEven = ! FEven;
01052 FDartCurrent = FMap->alpha(FDartCurrent, Aj);
01053 FPrevOp = OP_ALPHAJ;
01054 }
01055 }
01056 else
01057 {
01058 FEven = ! FEven;
01059 FDartCurrent = FMap->alpha(FDartCurrent, Ai);
01060 FPrevOp =OP_ALPHAI;
01061 }
01062 }
01063 else
01064 {
01065 if (FMap->alpha(FDartCurrent, Ai) == FDart1)
01066 {
01067 if (! FMap->isFree(FDartCurrent, Aj))
01068 {
01069 FEven = ! FEven;
01070 FDartCurrent = FMap->alpha(FDartCurrent, Aj);
01071 FPrevOp = OP_ALPHAJ;
01072 }
01073 else
01074 FPrevOp = OP_END;
01075 }
01076 else
01077 FPrevOp = OP_END;
01078 }
01079 }
01080
01081 template <int Ai, int Aj>
01082 inline
01083 TOperationState CTemplateDynamicCoverage2a<Ai,Aj>::prevOperationType()
01084 {
01085 return FPrevOp;
01086 }
01087
01088 template <int Ai, int Aj>
01089 inline
01090 CDart* CTemplateDynamicCoverage2a<Ai,Aj>::operator*()
01091 {
01092 assert(cont());
01093 return FDartCurrent;
01094 }
01095
01096 template <int Ai, int Aj>
01097 inline
01098 CDart* CTemplateDynamicCoverage2a<Ai,Aj>::operator++(int)
01099 {
01100 CDart* tmp = operator*();
01101
01102 operator++();
01103 return tmp;
01104 }
01105
01106 template <int Ai, int Aj>
01107 inline
01108 int CTemplateDynamicCoverage2a<Ai,Aj>::type() const
01109 {
01110 return COVERAGE2A;
01111 }
01112
01113
01114
01115 template <int Ai, int Aj>
01116 inline
01117 void CTemplateDynamicCoverage2b<Ai,Aj>::reinit()
01118 {
01119 FDartCurrent = FDart1;
01120 FFirstDirection = true;
01121 FNextTryAi = true;
01122 FPrevOp = OP_NONE;
01123 }
01124
01125 template <int Ai, int Aj>
01126 inline
01127 CTemplateDynamicCoverage2b<Ai,Aj>::
01128 CTemplateDynamicCoverage2b(CGMapBasic* AGMap, const CDart* ADart1) :
01129 CCoverage(AGMap),
01130 FDart1 ((CDart*) ADart1)
01131 {
01132 reinit();
01133 }
01134
01135 template <int Ai, int Aj>
01136 inline
01137 CTemplateDynamicCoverage2b<Ai,Aj>::~CTemplateDynamicCoverage2b()
01138 {
01139 }
01140
01141 template <int Ai, int Aj>
01142 inline
01143 bool CTemplateDynamicCoverage2b<Ai,Aj>::cont()
01144 {
01145 return FPrevOp != OP_END;
01146 }
01147
01148 template <int Ai, int Aj>
01149 inline
01150 void CTemplateDynamicCoverage2b<Ai,Aj>::operator++()
01151 {
01152 assert(cont());
01153
01154 if (FFirstDirection)
01155 {
01156 if (FNextTryAi)
01157 {
01158 if (FMap->isFree(FDartCurrent, Ai))
01159 {
01160 FFirstDirection = false;
01161 if (FMap->isFree(FDart1, Aj))
01162 FPrevOp = OP_END;
01163 else
01164 {
01165 FDartCurrent = FMap->alpha(FDart1, Aj);
01166 FPrevOp = OP_JUMP;
01167 }
01168 }
01169 else
01170 {
01171 FDartCurrent = FMap->alpha(FDartCurrent, Ai);
01172 FNextTryAi = false;
01173 FPrevOp = OP_ALPHAI;
01174 }
01175 }
01176 else
01177 {
01178 if (FMap->isFree(FDartCurrent, Aj))
01179 {
01180 FFirstDirection = false;
01181 if (FMap->isFree(FDart1, Aj))
01182 FPrevOp = OP_END;
01183 else
01184 {
01185 FDartCurrent = FMap->alpha(FDart1, Aj);
01186 FNextTryAi = true;
01187 FPrevOp = OP_JUMP;
01188 }
01189 }
01190 else
01191 {
01192 FDartCurrent = FMap->alpha(FDartCurrent, Aj);
01193 if (FDartCurrent == FDart1)
01194 FPrevOp = OP_END;
01195 else
01196 {
01197 FNextTryAi = true;
01198 FPrevOp = OP_ALPHAJ;
01199 }
01200 }
01201 }
01202 }
01203 else
01204 {
01205 if (FNextTryAi)
01206 {
01207 if (FMap->isFree(FDartCurrent, Ai))
01208 FPrevOp = OP_END;
01209 else
01210 {
01211 FDartCurrent = FMap->alpha(FDartCurrent, Ai);
01212 FNextTryAi = false;
01213 FPrevOp = OP_ALPHAI;
01214 }
01215 }
01216 else
01217 {
01218 if (FMap->isFree(FDartCurrent, Aj))
01219 FPrevOp = OP_END;
01220 else
01221 {
01222 FDartCurrent = FMap->alpha(FDartCurrent, Aj);
01223 FNextTryAi = true;
01224 FPrevOp = OP_ALPHAJ;
01225 }
01226 }
01227 }
01228 }
01229
01230 template <int Ai, int Aj>
01231 inline
01232 TOperationState CTemplateDynamicCoverage2b<Ai,Aj>::prevOperationType()
01233 {
01234 return FPrevOp;
01235 }
01236
01237 template <int Ai, int Aj>
01238 inline
01239 CDart* CTemplateDynamicCoverage2b<Ai,Aj>::operator*()
01240 {
01241 assert(cont());
01242
01243 return FDartCurrent;
01244 }
01245
01246 template <int Ai, int Aj>
01247 inline
01248 CDart* CTemplateDynamicCoverage2b<Ai,Aj>::operator++(int )
01249 {
01250 CDart* tmp = operator*();
01251 operator++();
01252 return tmp;
01253 }
01254
01255 template <int Ai, int Aj>
01256 inline
01257 int CTemplateDynamicCoverage2b<Ai,Aj>::type() const
01258 {
01259 return COVERAGE2B;
01260 }
01261
01262
01263
01264 template <int Ai, int Aj, int Ak>
01265 inline
01266 void CTemplateDynamicCoverage3a<Ai,Aj,Ak>::reinit()
01267 {
01268 FFirstBorder = true;
01269 FPrevAk = false;
01270 FIt.reinit();
01271 }
01272
01273 template <int Ai, int Aj, int Ak>
01274 inline
01275 CTemplateDynamicCoverage3a<Ai,Aj,Ak>::
01276 CTemplateDynamicCoverage3a(CGMapBasic* AGMap, const CDart* ADart1) :
01277 CCoverage(AGMap),
01278 FIt (AGMap, ADart1)
01279 {
01280 FAkExist = ! FMap->isFree(ADart1, Ak);
01281 reinit();
01282 }
01283
01284 template <int Ai, int Aj, int Ak>
01285 inline
01286 CTemplateDynamicCoverage3a<Ai,Aj,Ak>::~CTemplateDynamicCoverage3a()
01287 {
01288 }
01289
01290 template <int Ai, int Aj, int Ak>
01291 inline
01292 bool CTemplateDynamicCoverage3a<Ai,Aj,Ak>::cont()
01293 {
01294 return FIt.cont();
01295 }
01296
01297 template <int Ai, int Aj, int Ak>
01298 inline
01299 void CTemplateDynamicCoverage3a<Ai,Aj,Ak>::operator++()
01300 {
01301 assert(cont());
01302
01303 if (! FAkExist || FPrevAk)
01304 {
01305 ++ FIt;
01306
01307 if (FIt.cont())
01308 {
01309 if (FIt.prevOperationType() == OP_JUMP)
01310 FFirstBorder = true;
01311
01312 FPrevAk = false;
01313 }
01314 }
01315 else
01316 {
01317 FPrevAk = true;
01318 FFirstBorder = ! FFirstBorder;
01319 }
01320 }
01321
01322 template <int Ai, int Aj, int Ak>
01323 inline
01324 CDart* CTemplateDynamicCoverage3a<Ai,Aj,Ak>::operator*()
01325 {
01326 assert(cont());
01327
01328 if (FFirstBorder)
01329 return * FIt;
01330 else
01331 return FMap->alpha(* FIt, Ak);
01332 }
01333
01334 template <int Ai, int Aj, int Ak>
01335 inline
01336 CDart* CTemplateDynamicCoverage3a<Ai,Aj,Ak>::operator++(int)
01337 {
01338 CDart* tmp = operator*();
01339 operator++();
01340 return tmp;
01341 }
01342
01343 template <int Ai, int Aj, int Ak>
01344 inline
01345 TOperationState CTemplateDynamicCoverage3a<Ai,Aj,Ak>::prevOperationType()
01346 {
01347 if (FPrevAk)
01348 return OP_ALPHAK;
01349 else
01350 return FIt.prevOperationType();
01351 }
01352
01353 template <int Ai, int Aj, int Ak>
01354 inline
01355 int CTemplateDynamicCoverage3a<Ai,Aj,Ak>::type() const
01356 {
01357 return COVERAGE3A;
01358 }
01359
01360
01361
01362 template <int Ai, int Aj, int Ak>
01363 inline
01364 CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::
01365 CTemplateBasicDynamicCoverage3b(CGMapBasic* AGMap, const CDart* ADart1,
01366 int AMarkNumber) :
01367 CCoverage (AGMap),
01368 FDartCurrent((CDart*) ADart1),
01369 FMarkNumber (AMarkNumber),
01370 FPrevOp (OP_NONE)
01371 {
01372 FMap->setMark(FDartCurrent, FMarkNumber);
01373 }
01374
01375 template <int Ai, int Aj, int Ak>
01376 inline
01377 CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::~CTemplateBasicDynamicCoverage3b()
01378 {
01379 }
01380
01381 template <int Ai, int Aj, int Ak>
01382 inline
01383 bool CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::cont()
01384 {
01385 return FPrevOp != OP_END;
01386 }
01387
01388 template <int Ai, int Aj, int Ak>
01389 inline
01390 void CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::reinit()
01391 {
01392 }
01393
01394 template <int Ai, int Aj, int Ak>
01395 inline
01396 void CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::operator++()
01397 {
01398 #define GET_ALPHAI_AND_MARK(D,AI) \
01399 ( FMap->setMark(FMap->alpha(D,AI), FMarkNumber), FMap->alpha(D,AI) )
01400
01401 #define IS_UNMARKED(D,AI) \
01402 ( ! FMap->isMarked(FMap->alpha(D,AI), FMarkNumber) )
01403
01404 #define PUSH_AND_MARK(D,AI) \
01405 ( FToTreat.push(GET_ALPHAI_AND_MARK(D,AI)) )
01406
01407 assert(cont());
01408
01409 CDart* nd = NULL;
01410
01411 if (IS_UNMARKED(FDartCurrent, Ai))
01412 {
01413 nd = GET_ALPHAI_AND_MARK(FDartCurrent, Ai);
01414 FPrevOp = OP_ALPHAI;
01415
01416 if (IS_UNMARKED(FDartCurrent, Aj))
01417 PUSH_AND_MARK(FDartCurrent, Aj);
01418
01419 if (IS_UNMARKED(FDartCurrent, Ak))
01420 PUSH_AND_MARK(FDartCurrent, Ak);
01421 }
01422 else if (IS_UNMARKED(FDartCurrent, Aj))
01423 {
01424 nd = GET_ALPHAI_AND_MARK(FDartCurrent, Aj);
01425 FPrevOp = OP_ALPHAJ;
01426
01427 if (IS_UNMARKED(FDartCurrent, Ak))
01428 PUSH_AND_MARK(FDartCurrent, Ak);
01429 }
01430 else if (IS_UNMARKED(FDartCurrent, Ak))
01431 {
01432 nd = GET_ALPHAI_AND_MARK(FDartCurrent, Ak);
01433 FPrevOp = OP_ALPHAK;
01434 }
01435 else if (! FToTreat.empty())
01436 {
01437 nd = FToTreat.front();
01438 FToTreat.pop();
01439 FPrevOp = OP_JUMP;
01440 }
01441 else
01442 FPrevOp = OP_END;
01443
01444 FDartCurrent = nd;
01445
01446 #undef PUSH_AND_MARK
01447 #undef IS_SEWED_AND_UNMARKED
01448 }
01449
01450 template <int Ai, int Aj, int Ak>
01451 inline
01452 TOperationState CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::prevOperationType()
01453 {
01454 return FPrevOp;
01455 }
01456
01457 template <int Ai, int Aj, int Ak>
01458 inline
01459 CDart* CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::operator*()
01460 {
01461 assert(cont());
01462 return FDartCurrent;
01463 }
01464
01465 template <int Ai, int Aj, int Ak>
01466 inline
01467 CDart* CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::operator ++ ( int )
01468 {
01469 CDart* tmp = operator*();
01470 operator ++();
01471 return tmp;
01472 }
01473
01474 template <int Ai, int Aj, int Ak>
01475 inline
01476 int CTemplateDynamicCoverage3b<Ai,Aj,Ak>::type() const
01477 {
01478 return COVERAGE3B;
01479 }
01480
01481
01482
01483 inline
01484 CTemplateBasicDynamicCoverage4::
01485 CTemplateBasicDynamicCoverage4(CGMapBasic* AGMap, const CDart* ADart1,
01486 int AMarkNumber) :
01487 CCoverage (AGMap),
01488 FDartCurrent((CDart*) ADart1),
01489 FMarkNumber (AMarkNumber),
01490 FPrevOp (OP_NONE)
01491 {
01492 FMap->setMark(FDartCurrent, FMarkNumber);
01493 }
01494
01495 inline
01496 CTemplateBasicDynamicCoverage4::~CTemplateBasicDynamicCoverage4()
01497 {
01498 }
01499
01500 inline
01501 bool CTemplateBasicDynamicCoverage4::cont()
01502 {
01503 return FPrevOp != OP_END;
01504 }
01505
01506 inline
01507 void CTemplateBasicDynamicCoverage4::reinit()
01508 {
01509 }
01510
01511 inline
01512 void CTemplateBasicDynamicCoverage4::operator ++()
01513 {
01514 assert(cont());
01515
01516 CDart*nd=NULL;
01517
01518 #define IS_SEWED_AND_UNMARKED(D,AI) \
01519 ! FMap->isFree(D,AI) && ! FMap->isMarked(FMap->alpha(D,AI), FMarkNumber)
01520
01521 if (IS_SEWED_AND_UNMARKED(FDartCurrent,0))
01522 {
01523 nd = FMap->alpha0(FDartCurrent);
01524 FMap->setMark(nd, FMarkNumber);
01525 FPrevOp = OP_ALPHA0;
01526
01527 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 1))
01528 {
01529 FToTreat.push(FMap->alpha1(FDartCurrent));
01530 FMap->setMark(FMap->alpha1(FDartCurrent),FMarkNumber);
01531 }
01532
01533 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 2))
01534 {
01535 FToTreat.push(FMap->alpha2(FDartCurrent));
01536 FMap->setMark(FMap->alpha2(FDartCurrent), FMarkNumber);
01537 }
01538
01539 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 3))
01540 {
01541 FToTreat.push(FMap->alpha3(FDartCurrent));
01542 FMap->setMark(FMap->alpha3(FDartCurrent), FMarkNumber);
01543 }
01544 }
01545 else if (IS_SEWED_AND_UNMARKED(FDartCurrent, 1))
01546 {
01547 nd = FMap->alpha1(FDartCurrent);
01548 FMap->setMark(nd, FMarkNumber);
01549 FPrevOp = OP_ALPHA1;
01550
01551 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 2))
01552 {
01553 FToTreat.push(FMap->alpha2(FDartCurrent));
01554 FMap->setMark(FMap->alpha2(FDartCurrent), FMarkNumber);
01555 }
01556
01557 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 3))
01558 {
01559 FToTreat.push(FMap->alpha3(FDartCurrent));
01560 FMap->setMark(FMap->alpha3(FDartCurrent), FMarkNumber);
01561 }
01562 }
01563 else if (IS_SEWED_AND_UNMARKED(FDartCurrent, 2))
01564 {
01565 nd = FMap->alpha2(FDartCurrent);
01566 FMap->setMark(nd, FMarkNumber);
01567 FPrevOp = OP_ALPHA2;
01568
01569 if (IS_SEWED_AND_UNMARKED(FDartCurrent, 3))
01570 {
01571 FToTreat.push(FMap->alpha3(FDartCurrent));
01572 FMap->setMark(FMap->alpha3(FDartCurrent), FMarkNumber);
01573 }
01574 }
01575 else if (IS_SEWED_AND_UNMARKED(FDartCurrent, 3))
01576 {
01577 nd = FMap->alpha3(FDartCurrent);
01578 FMap->setMark(nd, FMarkNumber);
01579 FPrevOp = OP_ALPHA3;
01580 }
01581 else if (! FToTreat.empty())
01582 {
01583 nd = FToTreat.front();
01584 FToTreat.pop();
01585 FPrevOp = OP_UNKNOWN;
01586 }
01587 else
01588 FPrevOp = OP_END;
01589
01590 #undef IS_SEWED_AND_UNMARKED
01591
01592 FDartCurrent = nd;
01593 }
01594
01595 inline
01596 TOperationState CTemplateBasicDynamicCoverage4::prevOperationType()
01597 {
01598 return FPrevOp;
01599 }
01600
01601 inline
01602 CDart* CTemplateBasicDynamicCoverage4::operator*()
01603 {
01604 assert(cont());
01605
01606 return FDartCurrent;
01607 }
01608
01609 inline
01610 CDart* CTemplateBasicDynamicCoverage4::operator++(int)
01611 {
01612 CDart* tmp = operator*();
01613
01614 operator++();
01615 return tmp;
01616 }
01617
01618 inline
01619 int CTemplateBasicDynamicCoverage4::type() const
01620 {
01621 return COVERAGE4;
01622 }
01623
01624
01625
01626 template <int Ai, int Aj, int Ak>
01627 inline
01628 void CTemplateDynamicCoverage3b<Ai,Aj,Ak>::reinit()
01629 {
01630 if (FIt != NULL)
01631 {
01632 delete FIt;
01633
01634 FMap->negateMaskMark(FMarkNumber);
01635
01636 FIt = new CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>
01637 (FMap, FDart1, FMarkNumber);
01638
01639 while (FIt->cont())
01640 ++ * FIt;
01641
01642 FMap->negateMaskMark(FMarkNumber);
01643 delete FIt;
01644 }
01645
01646 FIt = new CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>
01647 (FMap, FDart1, FMarkNumber);
01648 }
01649
01650 template <int Ai, int Aj, int Ak>
01651 inline
01652 CTemplateDynamicCoverage3b<Ai,Aj,Ak>::
01653 CTemplateDynamicCoverage3b(CGMapBasic* AGMap, const CDart* ADart1) :
01654 CCoverage(AGMap),
01655 FDart1 ((CDart*) ADart1),
01656 FIt (NULL)
01657 {
01658 FMarkNumber = FMap->getNewMark();
01659 reinit();
01660 }
01661
01662 template <int Ai, int Aj, int Ak>
01663 inline
01664 CTemplateDynamicCoverage3b<Ai,Aj,Ak>::~CTemplateDynamicCoverage3b()
01665 {
01666 delete FIt;
01667
01668 FMap->negateMaskMark(FMarkNumber);
01669
01670 FIt =
01671 new CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>(FMap, FDart1, FMarkNumber);
01672
01673 while (FIt->cont())
01674 ++ * FIt;
01675
01676 FMap->negateMaskMark(FMarkNumber);
01677
01678 delete FIt;
01679
01680 FMap->freeMark(FMarkNumber);
01681 }
01682
01683 template <int Ai, int Aj, int Ak>
01684 inline
01685 bool CTemplateDynamicCoverage3b<Ai,Aj,Ak>::cont()
01686 {
01687 return FIt->cont();
01688 }
01689
01690 template <int Ai, int Aj, int Ak>
01691 inline
01692 void CTemplateDynamicCoverage3b<Ai,Aj,Ak>::operator ++()
01693 {
01694 FIt->operator++();
01695 }
01696
01697 template <int Ai, int Aj, int Ak>
01698 inline
01699 TOperationState CTemplateDynamicCoverage3b<Ai,Aj,Ak>::prevOperationType()
01700 {
01701 return FIt->prevOperationType();
01702 }
01703
01704 template <int Ai, int Aj, int Ak>
01705 inline
01706 CDart* CTemplateDynamicCoverage3b<Ai,Aj,Ak>::operator*()
01707 {
01708 return FIt->operator*();
01709 }
01710
01711 template <int Ai, int Aj, int Ak>
01712 inline
01713 CDart* CTemplateDynamicCoverage3b<Ai,Aj,Ak>::operator++(int)
01714 {
01715 CDart* tmp = operator*();
01716 operator++();
01717 return tmp;
01718 }
01719
01720 template <int Ai, int Aj, int Ak>
01721 inline
01722 int CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>::type() const
01723 {
01724 return COVERAGE3B;
01725 }
01726
01727
01728
01729 inline
01730 void CTemplateDynamicCoverage4::reinit()
01731 {
01732 if (FIt != NULL)
01733 {
01734 delete FIt;
01735
01736 FMap->negateMaskMark(FMarkNumber);
01737
01738 FIt = new CTemplateBasicDynamicCoverage4(FMap, FDart1, FMarkNumber);
01739
01740 while (FIt->cont())
01741 ++ * FIt;
01742
01743 FMap->negateMaskMark(FMarkNumber);
01744
01745 delete FIt;
01746 }
01747
01748 FIt = new CTemplateBasicDynamicCoverage4(FMap, FDart1, FMarkNumber);
01749 }
01750
01751 inline
01752 CTemplateDynamicCoverage4::CTemplateDynamicCoverage4(CGMapBasic* AGMap,
01753 const CDart* ADart1) :
01754 CCoverage(AGMap),
01755 FDart1 ((CDart*) ADart1),
01756 FIt (NULL)
01757 {
01758 FMarkNumber = FMap->getNewMark();
01759 reinit();
01760 }
01761
01762 inline
01763 CTemplateDynamicCoverage4::~CTemplateDynamicCoverage4()
01764 {
01765 delete FIt;
01766
01767 FMap->negateMaskMark(FMarkNumber);
01768
01769 FIt = new CTemplateBasicDynamicCoverage4(FMap, FDart1, FMarkNumber);
01770
01771 while (FIt->cont())
01772 ++ * FIt;
01773
01774 FMap->negateMaskMark(FMarkNumber);
01775
01776 delete FIt;
01777
01778 FMap->freeMark(FMarkNumber);
01779 }
01780
01781 inline
01782 bool CTemplateDynamicCoverage4::cont()
01783 {
01784 return FIt->cont();
01785 }
01786
01787 inline
01788 void CTemplateDynamicCoverage4::operator++()
01789 {
01790 FIt->operator++();
01791 }
01792
01793 inline
01794 TOperationState CTemplateDynamicCoverage4::prevOperationType()
01795 {
01796 return FIt->prevOperationType();
01797 }
01798
01799 inline
01800 CDart* CTemplateDynamicCoverage4::operator*()
01801 {
01802 return FIt->operator*();
01803 }
01804
01805 inline
01806 CDart* CTemplateDynamicCoverage4::operator++(int)
01807 {
01808 CDart* tmp = operator*();
01809 operator++();
01810 return tmp;
01811 }
01812
01813 inline
01814 int CTemplateDynamicCoverage4::type() const
01815 {
01816 return COVERAGE4;
01817 }
01818
01819
01820
01821 template <int Ai, int Aj, int Ak>
01822 inline
01823 void CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::reinit()
01824 {
01825 if (FIt1 != NULL)
01826 {
01827 delete FIt1;
01828 FIt1 = NULL;
01829 }
01830
01831 FIt2 = FAllCoverDarts.begin();
01832 }
01833
01834 template <int Ai, int Aj, int Ak>
01835 inline
01836 CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::
01837 CTemplateMultiDynamicCoverage3b(CGMapBasic* AGMap, const CDart* ADart1) :
01838 CCoverage(AGMap)
01839 {
01840 FMarkNumber = AGMap->getNewMark();
01841 FIt1 = new CTemplateBasicDynamicCoverage3b<Ai,Aj,Ak>(AGMap, ADart1,
01842 FMarkNumber);
01843 }
01844
01845 template <int Ai, int Aj, int Ak>
01846 inline
01847 CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::~CTemplateMultiDynamicCoverage3b()
01848 {
01849 if (FIt1 != NULL)
01850 delete FIt1;
01851
01852 while (! FAllCoverDarts.empty())
01853 {
01854 FMap->unsetMark(FAllCoverDarts.front(), FMarkNumber);
01855 FAllCoverDarts.pop_front();
01856 }
01857
01858 FMap->freeMark(FMarkNumber);
01859 }
01860
01861 template <int Ai, int Aj, int Ak>
01862 inline
01863 bool CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::cont()
01864 {
01865 if (FIt1 != NULL)
01866 return FIt1->cont();
01867 else
01868 return FIt2 != FAllCoverDarts.end();
01869 }
01870
01871 template <int Ai, int Aj, int Ak>
01872 inline
01873 void CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::operator++()
01874 {
01875 if (FIt1 != NULL)
01876 FIt1->operator++();
01877 else
01878 ++FIt2;
01879 }
01880
01881 template <int Ai, int Aj, int Ak>
01882 inline
01883 TOperationState CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::prevOperationType()
01884 {
01885 if (FIt1 != NULL)
01886 return FIt1->prevOperationType();
01887 else
01888 return OP_UNKNOWN;
01889 }
01890
01891 template <int Ai, int Aj, int Ak>
01892 inline
01893 CDart* CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::operator*()
01894 {
01895 assert(cont());
01896
01897 if (FIt1 != NULL)
01898 return FIt1->operator*();
01899 else
01900 return * FIt2;
01901 }
01902
01903 template <int Ai, int Aj, int Ak>
01904 inline
01905 CDart* CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::operator++(int)
01906 {
01907 CDart* tmp = operator*();
01908 operator ++();
01909 return tmp;
01910 }
01911
01912 template <int Ai, int Aj, int Ak>
01913 inline
01914 int CTemplateMultiDynamicCoverage3b<Ai,Aj,Ak>::type() const
01915 {
01916 return COVERAGE3B;
01917 }
01918
01919
01920
01921 inline
01922 void CTemplateMultiDynamicCoverage4::reinit()
01923 {
01924 if (FIt1 != NULL)
01925 {
01926 delete FIt1;
01927 FIt1 = NULL;
01928 }
01929
01930 FIt2 = FAllCoverDarts.begin();
01931 }
01932
01933 inline
01934 CTemplateMultiDynamicCoverage4::
01935 CTemplateMultiDynamicCoverage4(CGMapBasic* AGMap, const CDart* ADart1) :
01936 CCoverage(AGMap)
01937 {
01938 FMarkNumber = AGMap->getNewMark();
01939 FIt1 = new CTemplateBasicDynamicCoverage4(AGMap, ADart1, FMarkNumber);
01940 }
01941
01942 inline
01943 CTemplateMultiDynamicCoverage4::~CTemplateMultiDynamicCoverage4()
01944 {
01945 if (FIt1 != NULL)
01946 delete FIt1;
01947
01948 while (! FAllCoverDarts.empty())
01949 {
01950 FMap->unsetMark(FAllCoverDarts.front(), FMarkNumber);
01951 FAllCoverDarts.pop_front();
01952 }
01953
01954 FMap->freeMark(FMarkNumber);
01955 }
01956
01957 inline
01958 bool CTemplateMultiDynamicCoverage4::cont()
01959 {
01960 if (FIt1 != NULL)
01961 return FIt1->cont();
01962 else
01963 return FIt2 != FAllCoverDarts.end();
01964 }
01965
01966 inline
01967 void CTemplateMultiDynamicCoverage4::operator++()
01968 {
01969 assert(cont());
01970
01971 if (FIt1 != NULL)
01972 FIt1->operator++();
01973 else
01974 ++FIt2;
01975 }
01976
01977 inline
01978 TOperationState CTemplateMultiDynamicCoverage4::prevOperationType()
01979 {
01980 if (FIt1 != NULL)
01981 return FIt1->prevOperationType();
01982 else
01983 return OP_UNKNOWN;
01984 }
01985
01986 inline
01987 CDart* CTemplateMultiDynamicCoverage4::operator*()
01988 {
01989 if (FIt1 != NULL)
01990 return FIt1->operator*();
01991 else
01992 return * FIt2;
01993 }
01994
01995 inline
01996 CDart* CTemplateMultiDynamicCoverage4::operator++(int)
01997 {
01998 CDart* tmp = operator*();
01999 operator++();
02000 return tmp;
02001 }
02002
02003 inline
02004 int CTemplateMultiDynamicCoverage4::type() const
02005 {
02006 return COVERAGE4;
02007 }
02008
02009
02010
02011 inline
02012 void CDynamicCoverageAll::reinit()
02013 {
02014 FCurrent = FMap->getFirstDart();
02015 }
02016
02017 inline
02018 CDynamicCoverageAll::CDynamicCoverageAll(CGMapBasic* AGMap)
02019 : CCoverage(AGMap)
02020 {
02021 reinit();
02022 }
02023
02024 inline
02025 CDynamicCoverageAll::~CDynamicCoverageAll()
02026 {
02027 }
02028
02029 inline
02030 bool CDynamicCoverageAll::cont()
02031 {
02032 return FCurrent != NULL;
02033 }
02034
02035 inline
02036 void CDynamicCoverageAll::operator++()
02037 {
02038 assert(cont());
02039 FCurrent = FCurrent->getNext();
02040 }
02041
02042 inline
02043 CDart* CDynamicCoverageAll::operator*()
02044 {
02045 assert(cont());
02046
02047 return FCurrent;
02048 }
02049
02050 inline
02051 CDart* CDynamicCoverageAll::operator++(int)
02052 {
02053 CDart* tmp = operator*();
02054 operator++();
02055 return tmp;
02056 }
02057
02058 inline
02059 TOperationState CDynamicCoverageAll::prevOperationType()
02060 {
02061 return OP_UNKNOWN;
02062 }
02063
02064 inline
02065 int CDynamicCoverageAll::type() const
02066 {
02067 return COVERAGE_ALL;
02068 }
02069
02070
02071
02072 inline
02073 CBasicBorderCoverage::CBasicBorderCoverage(CGMapBasic* AGMap,
02074 const CDart* ADart1,
02075 int AMarkNumber, int ADimension) :
02076 CCoverage (AGMap),
02077 FCurrentDart((CDart*) ADart1),
02078 FMarkNumber (AMarkNumber),
02079 FBorderDim (ADimension),
02080 FPrevOp (OP_NONE)
02081 {
02082 assert(FMap->isFree(ADart1, ADimension));
02083 AGMap->setMark((CDart*) ADart1, FMarkNumber);
02084 }
02085
02086 inline
02087 CBasicBorderCoverage::~CBasicBorderCoverage()
02088 {
02089 }
02090
02091 inline
02092 bool CBasicBorderCoverage::cont()
02093 {
02094 return FPrevOp != OP_END;
02095 }
02096
02097 inline
02098 void CBasicBorderCoverage::reinit()
02099 {
02100 }
02101
02102 inline
02103 void CBasicBorderCoverage::operator++()
02104 {
02105 assert(cont());
02106
02107 CDart* n = FCurrentDart;
02108 FPrevOp = OP_JUMP;
02109
02110 if (FBorderDim != 0)
02111 {
02112 do
02113 n = FMap->alpha(FMap->alpha(n,FBorderDim-1),FBorderDim);
02114 while (! FMap->isFree(n, FBorderDim) &&
02115 ! FMap->isFree(n, FBorderDim-1) && n != FCurrentDart);
02116
02117 if (! FMap->isMarked(n, FMarkNumber) && FMap->isFree(n, FBorderDim))
02118 {
02119 FToTreat.push(n);
02120 FMap->setMark(n, FMarkNumber);
02121 FPrevOp = OP_TURN_AROUND;
02122 }
02123 }
02124
02125 for (int i=3; i>=0; --i)
02126 if ((i<FBorderDim-1 || i>FBorderDim+1) &&
02127 ! FMap->isMarked(FMap->alpha(FCurrentDart, i), FMarkNumber))
02128 {
02129 FPrevOp = OP_ALPHA0 + i;
02130 FToTreat.push(FMap->alpha(FCurrentDart, i));
02131 FMap->setMark(FMap->alpha(FCurrentDart, i), FMarkNumber);
02132 }
02133
02134 if (FToTreat.empty())
02135 FPrevOp = OP_END;
02136 else
02137 {
02138 FCurrentDart = FToTreat.top();
02139 FToTreat.pop();
02140 }
02141 }
02142
02143 inline
02144 CDart* CBasicBorderCoverage::operator*()
02145 {
02146 assert(cont());
02147
02148 return FCurrentDart;
02149 }
02150
02151 inline
02152 CDart* CBasicBorderCoverage::operator++(int)
02153 {
02154 CDart* tmp = operator*();
02155 operator++();
02156 return tmp;
02157 }
02158
02159 inline
02160 TOperationState CBasicBorderCoverage::prevOperationType()
02161 {
02162 return FPrevOp;
02163 }
02164
02165 inline
02166 int CBasicBorderCoverage::type() const
02167 {
02168 return COVERAGE_BORDER;
02169 }
02170
02171
02172
02173 inline
02174 void CDynamicBorderCoverage::reinit()
02175 {
02176 if (FIt != NULL)
02177 {
02178 delete FIt;
02179
02180 FMap->negateMaskMark(FMarkNumber);
02181
02182 FIt = new CBasicBorderCoverage(FMap, FDart1, FMarkNumber, FBorderDim);
02183
02184 while (FIt->cont())
02185 ++ * FIt;
02186
02187 FMap->negateMaskMark(FMarkNumber);
02188
02189 delete FIt;
02190 }
02191
02192 FIt = new CBasicBorderCoverage(FMap, FDart1, FMarkNumber, FBorderDim);
02193 }
02194
02195 inline
02196 CDynamicBorderCoverage::CDynamicBorderCoverage(CGMapBasic* AGMap,
02197 const CDart* ADart1, int ADim) :
02198 CCoverage (AGMap),
02199 FDart1 ((CDart*) ADart1),
02200 FBorderDim(ADim),
02201 FIt (NULL)
02202 {
02203 FMarkNumber = FMap->getNewMark();
02204 reinit();
02205 }
02206
02207 inline
02208 CDynamicBorderCoverage::~CDynamicBorderCoverage()
02209 {
02210 while (FIt->cont())
02211 ++ * FIt;
02212
02213 delete FIt;
02214
02215 FMap->negateMaskMark(FMarkNumber);
02216
02217 FIt = new CBasicBorderCoverage(FMap, FDart1, FMarkNumber, FBorderDim);
02218
02219 while (FIt->cont())
02220 ++ * FIt;
02221
02222 delete FIt;
02223 FMap->negateMaskMark(FMarkNumber);
02224
02225 FMap->freeMark(FMarkNumber);
02226 }
02227
02228 inline
02229 bool CDynamicBorderCoverage::cont()
02230 {
02231 return FIt->cont();
02232 }
02233
02234 inline
02235 void CDynamicBorderCoverage::operator ++()
02236 {
02237 FIt->operator++();
02238 }
02239
02240 inline
02241 CDart* CDynamicBorderCoverage::operator*()
02242 {
02243 return FIt->operator*();
02244 }
02245
02246 inline
02247 CDart* CDynamicBorderCoverage::operator ++ ( int )
02248 {
02249 CDart* tmp = operator*();
02250 operator++();
02251 return tmp;
02252 }
02253
02254 inline
02255 TOperationState CDynamicBorderCoverage::prevOperationType()
02256 {
02257 return FIt->prevOperationType();
02258 }
02259
02260 inline
02261 int CDynamicBorderCoverage::type() const
02262 {
02263 return COVERAGE_BORDER;
02264 }
02265
02266 }
02267
02268 #endif // DYNAMIC_COVERAGE_HH
02269
