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
00029
00030
00031
00032
00033
00034 #include "ineq-op.hh"
00035 #include "definition.hh"
00036 #include "ineq-table-6-att.hh"
00037 #include "ineq-table-2-att.hh"
00038 #include "ineq-use-att.hh"
00039 #include "attribute-vertex.hh"
00040
00041 namespace GMap3d
00042 {
00043
00044
00045
00046
00047
00048
00049
00050
00051 void Create_Vertex_Ineq(CGMap * G, CDart * dgm, int markVertex)
00052 {
00053 CAttribute *currentAttribute;
00054 CVertex *currentPoint;
00055
00056
00057 currentAttribute = G->getAttribute(dgm,ORBIT_123,VERTEX_ATTRIBUTE_ID);
00058 currentPoint = (CAttributeVertex*)currentAttribute;
00059 G->addAttribute(dgm,ORBIT_123,new Ineq_Table6_Att(*currentPoint));
00060
00061
00062 CCoverage* DCv = G->getDynamicCoverage(dgm, ORBIT_123);
00063 for (DCv->reinit(); DCv->cont(); (*DCv)++)
00064 G->setMark(**DCv, markVertex);
00065 delete DCv;
00066 }
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076 void Create_Edges_Ineq(CGMap * G, CDart * dgm, int markEdge)
00077 {
00078 CAttribute *currentAttribute;
00079 CVertex *p1, *p2;
00080
00081
00082 CCoverage* DC01 = G->getDynamicCoverage(dgm, ORBIT_01);
00083 for (DC01->reinit(); DC01->cont(); (*DC01)++)
00084 {
00085 CDart* d01 = **DC01;
00086
00087
00088 if (!G->isMarked(d01, markEdge))
00089 {
00090
00091 currentAttribute = G->getAttribute(d01,ORBIT_123,
00092 VERTEX_ATTRIBUTE_ID);
00093 p1 = (CAttributeVertex*)currentAttribute;
00094
00095
00096 currentAttribute = G->getAttribute(G->alpha0(d01),ORBIT_123,
00097 VERTEX_ATTRIBUTE_ID);
00098 p2 = (CAttributeVertex*)currentAttribute;
00099
00100
00101 G->addAttribute(d01,ORBIT_023,new Ineq_Table6_Att(*p1, *p2));
00102
00103
00104 CCoverage* DCe = G->getDynamicCoverage(d01, ORBIT_023);
00105 for (DCe->reinit();DCe->cont(); (*DCe)++)
00106 G->setMark(**DCe, markEdge);
00107 delete DCe;
00108 }
00109 }
00110 delete DC01;
00111 }
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121 void Create_Face_Ineq(CGMap * G, CDart * dgm, int markFace)
00122 {
00123 CAttribute *currentAttribute;
00124 CVertex *currentPoint, *p1, *p2;;
00125
00126
00127 if (G->getAttribute(dgm, ORBIT_013, INT_ATTRIBUTE_ID))
00128 {
00129
00130 currentAttribute = G->getAttribute(dgm,ORBIT_123, VERTEX_ATTRIBUTE_ID);
00131 currentPoint = (CAttributeVertex*)currentAttribute;
00132
00133
00134 currentAttribute = G->getAttribute(G->alpha0(dgm), ORBIT_123,
00135 VERTEX_ATTRIBUTE_ID);
00136 p1 = (CAttributeVertex*)currentAttribute;
00137
00138
00139 currentAttribute = G->getAttribute(G->alpha0(G->alpha1(dgm)),
00140 ORBIT_123, VERTEX_ATTRIBUTE_ID);
00141 p2 = (CAttributeVertex*)currentAttribute;
00142
00143
00144 G->addAttribute(dgm,ORBIT_013,new Ineq_Table2_Att(*currentPoint, *p1,
00145 *p2));
00146
00147
00148 CCoverage* DCf = G->getDynamicCoverage(dgm, ORBIT_013);
00149 for (DCf->reinit(); DCf->cont(); (*DCf)++)
00150 G->setMark(**DCf, markFace);
00151 delete DCf;
00152 }
00153 else
00154 G->setMark(dgm, markFace);
00155 }
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165 void Create_Ineq(CGMap *G)
00166 {
00167
00168 int markVertex = G->getNewMark();
00169 int markFace = G->getNewMark();
00170 int markEdge = G->getNewMark();
00171
00172
00173
00174 CDynamicCoverageAll Cgm(G);
00175 for (Cgm.reinit(); Cgm.cont(); Cgm++)
00176 {
00177 CDart* dgm = *Cgm;
00178
00179
00180 if (!G->isMarked(dgm, markVertex))
00181 Create_Vertex_Ineq(G, dgm, markVertex);
00182
00183
00184 if (!G->isMarked(dgm, markEdge) && !G->isFree0(dgm))
00185 Create_Edges_Ineq(G, dgm, markEdge);
00186
00187
00188 if (!G->isMarked(dgm, markFace))
00189 Create_Face_Ineq(G, dgm, markFace);
00190 }
00191
00192
00193 for (Cgm.reinit(); Cgm.cont(); Cgm++)
00194 {
00195 G->unsetMark(*Cgm, markVertex);
00196 G->unsetMark(*Cgm, markFace);
00197 G->unsetMark(*Cgm, markEdge);
00198 }
00199 G->freeMark(markVertex);
00200 G->freeMark(markFace);
00201 G->freeMark(markEdge);
00202
00203 }
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214 void Calculate_Bounding_Box(CGMap * G, CDart * d, TOrbit o, float minMaxXyz[6])
00215 {
00216 CDart * dO;
00217
00218
00219 int markVertex = G->getNewMark();
00220
00221
00222 if (d == NULL && o == ORBIT_0123)
00223 {
00224
00225 CDynamicCoverageAll Cgm(G);
00226 Cgm.reinit();
00227 dO = *Cgm;
00228
00229
00230
00231 CAttribute * alpha = G->getAttribute(dO,ORBIT_123,INEQ6_ATTRIBUTE_ID);
00232 Ineq_Table6 * t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00233
00234
00235 for (int i=0; i<6; i++)
00236 minMaxXyz[i] = t->Get_Ineq(i)->GetW();
00237
00238
00239 CCoverage* DCv = G->getDynamicCoverage(dO, ORBIT_123);
00240 for (DCv->reinit(); DCv->cont(); (*DCv)++)
00241 G->setMark(**DCv, markVertex);
00242 delete DCv;
00243
00244
00245 for (; Cgm.cont(); Cgm++)
00246 {
00247 dO = *Cgm;
00248
00249
00250 if (!G->isMarked(dO, markVertex))
00251 {
00252
00253 alpha = G->getAttribute(dO,ORBIT_123,INEQ6_ATTRIBUTE_ID);
00254 t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00255
00256
00257
00258 for (int i=0; i<6; i++)
00259 if (minMaxXyz[i] < t->Get_Ineq(i)->GetW())
00260 minMaxXyz[i] = t->Get_Ineq(i)->GetW();
00261 }
00262
00263 CCoverage* DCv = G->getDynamicCoverage(dO, ORBIT_123);
00264 for (DCv->reinit();
00265 DCv->cont();
00266 (*DCv)++)
00267 G->setMark(**DCv, markVertex);
00268 delete DCv;
00269 }
00270
00271 for (Cgm.reinit(); Cgm.cont(); Cgm++)
00272 G->unsetMark(*Cgm, markVertex);
00273 }
00274
00275
00276 else
00277 {
00278
00279 CAttribute * alpha = G->getAttribute(d,ORBIT_123,INEQ6_ATTRIBUTE_ID);
00280 Ineq_Table6 * t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00281
00282
00283 for (int i=0; i<6; i++)
00284 minMaxXyz[i] = t->Get_Ineq(i)->GetW();
00285
00286
00287 CCoverage* DCe = G->getDynamicCoverage(d, o);
00288 for (DCe->reinit(); DCe->cont(); (*DCe)++)
00289 {
00290 dO = **DCe;
00291
00292
00293 if (!G->isMarked(dO, markVertex))
00294 {
00295
00296 alpha = G->getAttribute(dO,ORBIT_123,INEQ6_ATTRIBUTE_ID);
00297 t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00298
00299
00300
00301 for (int i=0; i<6; i++)
00302 if (minMaxXyz[i] < t->Get_Ineq(i)->GetW())
00303 minMaxXyz[i] = t->Get_Ineq(i)->GetW();
00304
00305
00306 if (o == ORBIT_01)
00307 {
00308 G->setMark(dO, markVertex);
00309 G->setMark(G->alpha1(dO), markVertex);
00310 }
00311 else
00312 if (o == ORBIT_012)
00313 {
00314 G->setMark(dO, markVertex);
00315 G->setMark(G->alpha1(dO), markVertex);
00316 G->setMark(G->alpha2(dO), markVertex);
00317 }
00318 else
00319 if (o == ORBIT_0)
00320 G->setMark(dO, markVertex);
00321 else
00322 {
00323 G->setMark(dO, markVertex);
00324 G->setMark(G->alpha1(dO), markVertex);
00325 G->setMark(G->alpha2(dO), markVertex);
00326 G->setMark(G->alpha3(dO), markVertex);
00327 }
00328 }
00329 }
00330
00331
00332 for (DCe->reinit(); DCe->cont(); (*DCe)++)
00333 G->unsetMark(**DCe, markVertex);
00334 delete DCe;
00335 }
00336
00337 G->freeMark(markVertex);
00338 }
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350 void Ineq_Vertex_Set_Unused(CGMap * G, CDart * d, TOrbit o, float minMaxXyz[6])
00351 {
00352 CDart * dO;
00353 CAttribute * alpha;
00354 Ineq_Table6 * t;
00355
00356
00357 int markVertex = G->getNewMark();
00358
00359
00360 CCoverage* DCe = G->getDynamicCoverage(d, o);
00361 for (DCe->reinit(); DCe->cont(); (*DCe)++)
00362 {
00363 dO = **DCe;
00364
00365
00366 if (!G->isMarked(dO, markVertex))
00367 {
00368
00369 alpha = G->getAttribute(dO,ORBIT_123,INEQ6_ATTRIBUTE_ID);
00370 t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00371
00372
00373 for (int i=0; i<6; i++)
00374 if (fabs(minMaxXyz[i] - t->Get_Ineq(i)->GetW())>EPS)
00375 t->Get_Ineq(i)->Set_Unused();
00376
00377
00378 if (o == ORBIT_01)
00379 {
00380 G->setMark(dO, markVertex);
00381 G->setMark(G->alpha1(dO), markVertex);
00382 }
00383 else
00384 if (o == ORBIT_012)
00385 {
00386 G->setMark(dO, markVertex);
00387 G->setMark(G->alpha1(dO), markVertex);
00388 G->setMark(G->alpha2(dO), markVertex);
00389 }
00390 else
00391 G->setMark(dO, markVertex);
00392 }
00393 }
00394
00395
00396 for (DCe->reinit(); DCe->cont(); (*DCe)++)
00397 G->unsetMark(**DCe, markVertex);
00398 G->freeMark(markVertex);
00399
00400 delete DCe;
00401 }
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412 void Compare_Ineq_Vertex(CGMap* G, CDart* d, int markVertex)
00413 {
00414 float minMaxXyz[6];
00415
00416
00417 if (G->getEmbeddingOwner(d, ORBIT_013))
00418 {
00419
00420 Calculate_Bounding_Box(G, d, ORBIT_01, minMaxXyz);
00421
00422
00423 Ineq_Vertex_Set_Unused(G, d, ORBIT_01, minMaxXyz);
00424
00425
00426 CCoverage* DCv = G->getDynamicCoverage(d, ORBIT_01);
00427 for (DCv->reinit(); DCv->cont(); (*DCv)++)
00428 G->setMark(**DCv, markVertex);
00429 delete DCv;
00430 }
00431
00432
00433 else
00434 {
00435 if (!G->isFree0(d))
00436 {
00437
00438 Calculate_Bounding_Box(G, d, ORBIT_0, minMaxXyz);
00439
00440
00441 Ineq_Vertex_Set_Unused(G, d, ORBIT_0, minMaxXyz);
00442
00443
00444 G->setMark(d, markVertex);
00445 G->setMark(G->alpha0(d), markVertex);
00446 }
00447
00448 else
00449
00450 G->setMark(d, markVertex);
00451 }
00452 }
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463 void Compare_Ineq_Edge(CGMap* G, CDart* d, int markEdge)
00464 {
00465 CAttribute* alpha, * au;
00466 CDart* d01;
00467 CVertex* p;
00468
00469 bool badIneq;
00470
00471
00472 int markTemp = G->getNewMark();
00473
00474
00475 if (G->getEmbeddingOwner(d, ORBIT_013))
00476 {
00477
00478 alpha = G->getAttribute(d,ORBIT_023,INEQ6_ATTRIBUTE_ID);
00479 Ineq_Table6* t = ((Ineq_Table6_Att*)alpha)->Get_Data();
00480
00481
00482 au = new Ineq_Use_Att();
00483 Ineq_Use* u = ((Ineq_Use_Att*)au)->Get_Data();
00484
00485
00486 for(int j=0; j < 6; j++)
00487 {
00488 badIneq = false;
00489 Inequation i = *t->Get_Ineq(j);
00490
00491 if (j%2 == 0)
00492 {
00493
00494 i.SetW((i.GetW() - t->Get_Ineq(j+1)->GetW())/2.0);
00495 }
00496 else
00497 {
00498
00499 i.SetW((i.GetW() - t->Get_Ineq(j-1)->GetW())/2.0);
00500 }
00501
00502
00503 CCoverage* DCf = G->getDynamicCoverage(d, ORBIT_01);
00504 for (DCf->reinit();
00505 DCf->cont() && !badIneq;
00506 (*DCf)++)
00507 {
00508 d01 = **DCf;
00509
00510
00511 if (!G->isMarked(d01, markTemp))
00512 {
00513
00514 alpha = G->getAttribute(d01,ORBIT_123, VERTEX_ATTRIBUTE_ID);
00515 p = (CAttributeVertex*)alpha;
00516
00517
00518
00519 if(!t->Get_Ineq(j)->Test_Point (*p) || !i.Test_Point (*p))
00520 {
00521 badIneq = true;
00522
00523
00524
00525 t->Get_Ineq(j)->Set_Unused();
00526 u->Set_Unused(j);
00527 }
00528
00529 G->setMark(d01, markTemp);
00530 G->setMark(G->alpha1(d01), markTemp);
00531 }
00532 }
00533
00534
00535 for (DCf->reinit();
00536 DCf->cont();
00537 (*DCf)++)
00538 G->unsetMark(**DCf, markTemp);
00539 delete DCf;
00540 }
00541 G->addAttribute(d,ORBIT_0,au);
00542 }
00543
00544 G->freeMark(markTemp);
00545
00546
00547 G->setMark(d, markEdge);
00548
00549
00550 if(!G->isFree0(d))
00551
00552
00553 G->setMark(G->alpha0(d), markEdge);
00554 }
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564 void Choose_Ineq(CGMap* G)
00565 {
00566
00567 int markEdge = G->getNewMark();
00568 int markVertex = G->getNewMark();
00569
00570
00571 CDynamicCoverageAll Cgm(G);
00572 for (Cgm.reinit(); Cgm.cont(); Cgm++)
00573 {
00574 CDart* dgm = *Cgm;
00575
00576
00577 if (!G->isMarked(dgm, markVertex))
00578 Compare_Ineq_Vertex(G, dgm, markVertex);
00579
00580
00581 if (!G->isMarked(dgm, markEdge))
00582 Compare_Ineq_Edge(G, dgm, markEdge);
00583 }
00584
00585
00586 for (Cgm.reinit(); Cgm.cont(); Cgm++)
00587 {
00588 G->unsetMark(*Cgm, markVertex);
00589 G->unsetMark(*Cgm, markEdge);
00590 }
00591 G->freeMark(markVertex);
00592 G->freeMark(markEdge);
00593
00594 }
00595
00596 }