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 #include "g-map-generic.hh"
00026 using namespace GMap3d;
00027
00028 void CGMapGeneric::markOrbit(CDart * ADart, TOrbit AOrbit,
00029 int AMarkNumber)
00030 {
00031 assert(ADart!=NULL);
00032
00033 CCoverage * cov= getDynamicCoverage(ADart, AOrbit);
00034
00035 while (cov->cont())
00036 setMark((*cov)++, AMarkNumber);
00037
00038 delete cov;
00039 }
00040
00041 void CGMapGeneric::halfMarkOrbit(CDart * ADart, TOrbit AOrbit,
00042 int AMarkNumber)
00043 {
00044 assert(ADart!=NULL);
00045 assert(AOrbit>=ORBIT_SELF && AOrbit<=ORBIT_CC);
00046 assert(isOrientable(ADart, AOrbit));
00047
00048 bool usedDim[4];
00049 int selected = getNewMark();
00050
00051 for (int dim=0; dim<=3; ++dim)
00052 usedDim[dim] = AND_ORBIT(AOrbit, ORBIT_DIM[dim]) != ORBIT_SELF;
00053
00054 CCoverage * cov= getDynamicCoverage(ADart, AOrbit);
00055
00056 setMark(**cov, selected);
00057 setMark(**cov, AMarkNumber);
00058
00059 for (; cov->cont(); ++(*cov))
00060 if (!isMarked(**cov, selected))
00061 for (int dim=0; dim<=3; ++dim)
00062 if (usedDim[dim] && !isFree(**cov, dim))
00063 {
00064 setMark(alpha(**cov, dim), selected);
00065 setMark(alpha(**cov, dim), AMarkNumber);
00066 }
00067
00068 delete cov;
00069
00070 unmarkOrbit(ADart, AOrbit, selected);
00071 freeMark(selected);
00072 }
00073
00074 void CGMapGeneric::halfUnmarkOrbit(CDart * ADart, TOrbit AOrbit,
00075 int AMarkNumber)
00076 {
00077 negateMaskMark(AMarkNumber);
00078 halfMarkOrbit(ADart, AOrbit, AMarkNumber);
00079 negateMaskMark(AMarkNumber);
00080 }
00081
00082 void CGMapGeneric::unmarkOrbit(CDart * ADart, TOrbit AOrbit,
00083 int AMarkNumber)
00084 {
00085 assert(ADart!=NULL);
00086
00087 CCoverage * cov= getDynamicCoverage(ADart, AOrbit);
00088
00089 while (cov->cont())
00090 unsetMark((*cov)++, AMarkNumber);
00091
00092 delete cov;
00093 }
00094
00095 void CGMapGeneric::unmarkAll(int AMarkNumber)
00096 {
00097 CDynamicCoverageAll it(this);
00098
00099 while (it.cont())
00100 unsetMark(it++, AMarkNumber);
00101 }
00102
00103 int CGMapGeneric::markIncidentCells(TOrbit AOrbit,
00104 int AMarkNumberSrce, int AMarkNumberDest)
00105 {
00106 assert(AMarkNumberSrce!=AMarkNumberDest);
00107
00108 int treated = getNewMark();
00109 int nb_cells = 0;
00110
00111 CDynamicCoverageAll it(this);
00112
00113 for (; it.cont(); ++it)
00114 if (!isMarked(*it, treated))
00115 {
00116 if (isMarked(*it, AMarkNumberSrce))
00117 {
00118 markOrbit(*it, AOrbit, AMarkNumberDest);
00119 markOrbit(*it, AOrbit, treated );
00120 ++nb_cells;
00121 }
00122 else
00123 setMark(*it, treated);
00124 }
00125
00126 negateMaskMark(treated);
00127 freeMark(treated);
00128
00129 return nb_cells;
00130 }
00131
00132 int CGMapGeneric::markIncidentCells(TOrbit AOrbit, int AMarkNumber)
00133 {
00134 int mark = getNewMark();
00135
00136 markCopy(AMarkNumber, mark);
00137 int nb_cells = markIncidentCells(AOrbit, mark, AMarkNumber);
00138 unmarkAll(mark);
00139
00140 freeMark(mark);
00141
00142 return nb_cells;
00143 }
00144
00145 void CGMapGeneric::halfMarkIncidentCells(TOrbit AOrbit,
00146 int AMarkNumberSrce,
00147 int AMarkNumberDest)
00148 {
00149 assert(AMarkNumberSrce!=AMarkNumberDest);
00150
00151 int treated = getNewMark();
00152
00153 CDynamicCoverageAll it(this);
00154
00155 for (; it.cont(); ++it)
00156 if (!isMarked(*it, treated))
00157 {
00158 if (isMarked(*it, AMarkNumberSrce))
00159 {
00160 if (isOrientable(*it, AOrbit))
00161 {
00162 halfMarkOrbit(*it, AOrbit, AMarkNumberDest);
00163 halfMarkOrbit(*it, AOrbit, treated );
00164 }
00165 else
00166 {
00167 markOrbit(*it, AOrbit, AMarkNumberDest);
00168 markOrbit(*it, AOrbit, treated );
00169 }
00170 }
00171 else
00172 setMark(*it, treated);
00173 }
00174
00175 negateMaskMark(treated);
00176 freeMark(treated);
00177 }
00178
00179 void CGMapGeneric::markInterior(CDart * ADart, int ADimension,
00180 int AMarkBorder, int AMarkInterior)
00181 {
00182 assert(ADart != NULL);
00183 assert(2 <= ADimension && ADimension <= 3);
00184
00185 if (AMarkInterior < 0)
00186 AMarkInterior = AMarkBorder;
00187
00188 bool initialMarked = isMarked(ADart, AMarkBorder);
00189 unsetMark(ADart, AMarkBorder);
00190
00191 TOrbit orbit = ORBIT_CELL[1+ADimension];
00192
00193 CCoverage * cov = getBasicDynamicCoverage(ADart, orbit, AMarkInterior);
00194
00195 for (; cov->cont(); ++(*cov))
00196 setMark(**cov, AMarkInterior);
00197
00198 delete cov;
00199
00200 if (initialMarked)
00201 setMark(ADart, AMarkBorder);
00202 }
00203
00204 void CGMapGeneric::halfMarkIncidentCells(TOrbit AOrbit, int AMarkNumber)
00205 {
00206 int mark = getNewMark();
00207
00208 markCopy(AMarkNumber, mark);
00209 halfMarkIncidentCells(AOrbit, mark, AMarkNumber);
00210 unmarkAll(mark);
00211
00212 freeMark(mark);
00213 }
00214
00215 void CGMapGeneric::markIntersection(int AMarkNumber1, int AMarkNumber2,
00216 TOrbit AOrbit1,TOrbit AOrbit2,
00217 int AMarkResult,
00218 bool AInitialMarkIncidentCells)
00219 {
00220 assert(AMarkNumber1 != AMarkNumber2);
00221
00222 int m1 = getNewMark();
00223 int m2 = getNewMark();
00224
00225 if (AInitialMarkIncidentCells)
00226 {
00227 markIncidentCells(AOrbit1, AMarkNumber1, m1);
00228 markIncidentCells(AOrbit1, AMarkNumber2, m2);
00229 }
00230 else
00231 {
00232 markCopy(AMarkNumber1, m1);
00233 markCopy(AMarkNumber2, m2);
00234 }
00235
00236 markIncidentCells(AOrbit2, m1);
00237 markIncidentCells(AOrbit2, m2);
00238
00239 markCopy(m2, AMarkResult);
00240 markAnd(m1, AMarkResult);
00241
00242 unmarkAll(m1); freeMark(m1);
00243 unmarkAll(m2); freeMark(m2);
00244 }
00245
00246 void CGMapGeneric::markCopy(int AMarkNumberFrom, int AMarkNumberTo)
00247 {
00248 assert(AMarkNumberFrom!=AMarkNumberTo);
00249
00250 for (CDynamicCoverageAll it(this); it.cont(); ++it)
00251 setMarkTo(*it, AMarkNumberTo, isMarked(*it, AMarkNumberFrom));
00252 }
00253
00254 void CGMapGeneric::markCopy(int AMarkNumberFrom, int AMarkNumberTo,
00255 CDart * ADart, TOrbit AOrbit)
00256 {
00257 assert(AMarkNumberFrom!=AMarkNumberTo);
00258 assert(ADart!=NULL);
00259
00260 CCoverage * cov = getDynamicCoverage(ADart, AOrbit);
00261
00262 for (; cov->cont(); ++(*cov))
00263 setMarkTo(**cov, AMarkNumberTo, isMarked(**cov, AMarkNumberFrom));
00264
00265 delete cov;
00266 }
00267
00268 void CGMapGeneric::markAdd(int AMarkNumberFrom, int AMarkNumberTo)
00269 {
00270 assert(AMarkNumberFrom!=AMarkNumberTo);
00271
00272 CDynamicCoverageAll it(this);
00273
00274 for (; it.cont(); ++it)
00275 if (isMarked(*it, AMarkNumberFrom))
00276 setMark(*it, AMarkNumberTo);
00277 }
00278
00279 void CGMapGeneric::markAdd(int AMarkNumberFrom, int AMarkNumberTo,
00280 CDart * ADart, TOrbit AOrbit)
00281 {
00282 assert(AMarkNumberFrom!=AMarkNumberTo);
00283 assert(ADart!=NULL);
00284
00285 CCoverage * cov = getDynamicCoverage(ADart, AOrbit);
00286
00287 for (; cov->cont(); ++(*cov))
00288 if (isMarked(**cov, AMarkNumberFrom))
00289 setMark(**cov, AMarkNumberTo);
00290
00291 delete cov;
00292 }
00293
00294 void CGMapGeneric::markAnd(int AMarkNumberFrom, int AMarkNumberTo)
00295 {
00296 assert(AMarkNumberFrom!=AMarkNumberTo);
00297
00298 CDynamicCoverageAll it(this);
00299
00300 for (; it.cont(); ++it)
00301 if (!isMarked(*it, AMarkNumberFrom))
00302 unsetMark(*it, AMarkNumberTo);
00303 }
00304
00305 void CGMapGeneric::markAnd(int AMarkNumberFrom, int AMarkNumberTo,
00306 CDart * ADart, TOrbit AOrbit)
00307 {
00308 assert(AMarkNumberFrom!=AMarkNumberTo);
00309 assert(ADart!=NULL);
00310
00311 CCoverage * cov = getDynamicCoverage(ADart, AOrbit);
00312
00313 for (; cov->cont(); ++(*cov))
00314 if (!isMarked(**cov, AMarkNumberFrom))
00315 unsetMark(**cov, AMarkNumberTo);
00316
00317 delete cov;
00318 }
00319
00320 void CGMapGeneric::markSub(int AMarkNumberFrom, int AMarkNumberTo)
00321 {
00322 assert(AMarkNumberFrom!=AMarkNumberTo);
00323
00324 CDynamicCoverageAll it(this);
00325
00326 for (; it.cont(); ++it)
00327 if (isMarked(*it, AMarkNumberFrom))
00328 unsetMark(*it, AMarkNumberTo);
00329 }
00330
00331 void CGMapGeneric::markSub(int AMarkNumberFrom, int AMarkNumberTo,
00332 CDart * ADart, TOrbit AOrbit)
00333 {
00334 assert(AMarkNumberFrom!=AMarkNumberTo);
00335 assert(ADart!=NULL);
00336
00337 CCoverage * cov = getDynamicCoverage(ADart, AOrbit);
00338
00339 for (; cov->cont(); ++(*cov))
00340 if (isMarked(**cov, AMarkNumberFrom))
00341 unsetMark(**cov, AMarkNumberTo);
00342
00343 delete cov;
00344 }
00345
00346 void CGMapGeneric::markMove(int AMarkNumberFrom, int AMarkNumberTo)
00347 {
00348 assert(AMarkNumberFrom!=AMarkNumberTo);
00349
00350 CDynamicCoverageAll it(this);
00351
00352 for (; it.cont(); ++it)
00353 if (isMarked(*it, AMarkNumberFrom))
00354 {
00355 setMark (*it, AMarkNumberTo );
00356 unsetMark(*it, AMarkNumberFrom);
00357 }
00358 }
00359
00360 void CGMapGeneric::markMove(int AMarkNumberFrom, int AMarkNumberTo,
00361 CDart * ADart, TOrbit AOrbit)
00362 {
00363 assert(AMarkNumberFrom!=AMarkNumberTo);
00364 assert(ADart!=NULL);
00365
00366 CCoverage * cov = getDynamicCoverage(ADart, AOrbit);
00367
00368 for (; cov->cont(); ++(*cov))
00369 if (isMarked(**cov, AMarkNumberFrom))
00370 {
00371 setMark (**cov, AMarkNumberTo );
00372 unsetMark(**cov, AMarkNumberFrom);
00373 }
00374
00375 delete cov;
00376 }
00377
00378 bool CGMapGeneric::isWholeCellMarked(CDart * ADart, TOrbit AOrbit,
00379 int AMarkNumber)
00380 {
00381 assert(ADart!=NULL);
00382
00383 bool wholeCellMarked = true;
00384 CCoverage * it = getDynamicCoverage(ADart, AOrbit);
00385
00386 for (; it->cont() && wholeCellMarked; ++(*it))
00387 if (!isMarked(**it, AMarkNumber))
00388 wholeCellMarked = false;
00389
00390 delete it;
00391
00392 return wholeCellMarked;
00393 }
00394
00395 int CGMapGeneric::getMarkedCells(TOrbit AOrbit, int AMarkNumber,
00396 CDart * ALastMarked,
00397 CDart * * ADart1,
00398 CDart * * ADart2,
00399 CDart * * ADart3)
00400 {
00401 int maxToFind = ADart1==NULL ? 0 : ADart2==NULL ? 1 : ADart3==NULL ? 2 : 3;
00402 int nbFound = 0;
00403
00404 CDart * * dart[3] = {ADart1, ADart2, ADart3};
00405
00406 int treated = getNewMark();
00407
00408 for (int i=0; i<maxToFind; ++i)
00409 *dart[i] = NULL;
00410
00411 if (ALastMarked!=NULL && isMarked(ALastMarked, AMarkNumber))
00412 {
00413 markOrbit(ALastMarked, AOrbit, treated);
00414 *dart[nbFound++]= ALastMarked;
00415 }
00416
00417 for (CDynamicCoverageAll it(this); it.cont(); ++it)
00418 if (!isMarked(*it, treated))
00419 {
00420 if (isMarked(*it, AMarkNumber))
00421 {
00422 markOrbit(*it, AOrbit, treated);
00423
00424 if (nbFound<maxToFind)
00425 *dart[nbFound] = *it;
00426
00427 ++nbFound;
00428 }
00429 else
00430 setMark(*it, treated);
00431 }
00432
00433 negateMaskMark(treated);
00434 freeMark(treated);
00435
00436 return nbFound;
00437 }
00438