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-vertex.hh"
00026 #include "streams.hh"
00027 #include <cstring>
00028 #include <map>
00029 using namespace std;
00030 using namespace GMap3d;
00031
00032
00033 void CGMapVertex::linkFaceAlpha2OFF(vector< list<CDart*> >& ATestVertices,
00034 int AIndex, CDart* ADart)
00035 {
00036 CDart* current = ADart;
00037 do
00038 {
00039 unsigned int v1 = (unsigned int)getDirectInfo(current, AIndex);
00040 unsigned int v2 = (unsigned int)getDirectInfo(alpha0(current), AIndex);
00041
00042 list<CDart*>& tmp1 = ATestVertices[v1];
00043 list<CDart*>& tmp2 = ATestVertices[v2];
00044
00045
00046 list<CDart*>::iterator it;
00047 CDart* foundEdge = NULL;
00048 for (it = tmp1.begin(); foundEdge == NULL && it != tmp1.end(); ++it)
00049 {
00050 if (((unsigned int)getDirectInfo(alpha0(*it), AIndex)) == v2)
00051 {
00052 foundEdge = *it;
00053 }
00054 }
00055
00056 if (foundEdge != NULL)
00057 {
00058
00059 CVertex edge = edgeVector(foundEdge);
00060 CVertex vect1 =
00061 CGeometry::getNormalVector(faceNormalVector(foundEdge), edge);
00062
00063 CVertex vect2;
00064 CVertex vectNew =
00065 CGeometry::getNormalVector(faceNormalVector(current), edge);
00066
00067
00068
00069 bool here = false;
00070 bool roundingError = false;
00071 CDart* first = foundEdge;
00072
00073 TCoordinate angle1, angle2;
00074
00075 if (!isFree2(foundEdge))
00076 while (!here)
00077 {
00078 vect2 = CGeometry::getNormalVector
00079 (faceNormalVector(alpha23(foundEdge)), edge);
00080
00081 angle1 = positifAngle
00082 (CGeometry::getAngle(vect1, vect2, edge));
00083
00084 angle2 =
00085 positifAngle
00086 (CGeometry::getAngle(vect1, vectNew, edge)) +
00087 positifAngle
00088 (CGeometry::getAngle(vectNew, vect2, edge));
00089
00090 if (areEqual(angle1, angle2))
00091 here = true;
00092 else
00093 {
00094 vect1 = vect2;
00095 foundEdge = alpha23(foundEdge);
00096 }
00097
00098
00099 if (!here && foundEdge == first)
00100 {
00101 roundingError = true;
00102 here = true;
00103 }
00104 }
00105
00106 if (!roundingError)
00107 {
00108 if (isFree2(foundEdge))
00109 {
00110 sew2(alpha3(current), foundEdge);
00111 sew2(current, alpha3(foundEdge));
00112 }
00113 else
00114 {
00115 CDart* prev1 = alpha2(foundEdge);
00116 unsew2(foundEdge);
00117
00118 sew2(alpha3(current), foundEdge);
00119 sew2(current, prev1);
00120 }
00121 }
00122 }
00123 else
00124 {
00125
00126
00127 tmp1.push_back(current);
00128 tmp2.push_back(alpha03(current));
00129
00130
00131
00132 }
00133
00134 current = alpha01(current);
00135 }
00136 while (current != ADart);
00137 }
00138
00139 CDart* CGMapVertex::importOff2D(std::istream & AStream)
00140 {
00141
00142 vector< CVertex > initVertices;
00143 vector< list<CDart*> > testVertices;
00144
00145 string txt;
00146 TCoordinate x, y;
00147 CDart *d1 = NULL, *d2 = NULL;
00148 unsigned int v1, v2;
00149
00150 AStream >> txt;
00151 if (txt != "OFF2D")
00152 {
00153 cout << "Problème d'entête : fichier non OFF" << endl;
00154 return NULL;
00155 }
00156
00157 unsigned int nbSommets = 0;
00158 unsigned int nbAretes = 0;
00159
00160 AStream >> nbSommets >> nbAretes;
00161 while (nbSommets > 0)
00162 {
00163 if (!AStream.good())
00164 {
00165 cout << "Problème de lecture : pas assez de sommets" << endl;
00166 return NULL;
00167 }
00168
00169 AStream >> x >> y;
00170 initVertices.push_back(CVertex(x, y, 0));
00171 testVertices.push_back(list<CDart*>());
00172 --nbSommets;
00173 }
00174
00175 while (nbAretes > 0)
00176 {
00177 if (!AStream.good())
00178 {
00179 cout << "Problème de lecture : pas assez d'arêtes" << endl;
00180 return false;
00181 }
00182
00183
00184 AStream >> v1 >> v2; AStream.ignore(256,'\n');
00185 --nbAretes;
00186
00187 assert(v1 < initVertices.size());
00188 assert(v2 < initVertices.size());
00189
00190 d1 = addMapDart(initVertices[v1]);
00191 d2 = addMapDart(initVertices[v2]);
00192 linkAlpha0(d1, d2);
00193
00194 linkAlpha2(d1, addMapDart());
00195 linkAlpha2(d2, addMapDart());
00196 linkAlpha0(alpha2(d1), alpha2(d2));
00197
00198 testVertices[v1].push_back(d1);
00199 testVertices[v2].push_back(alpha2(d2));
00200 }
00201
00202 map<double, CDart*> tabDart;
00203 list<CDart*>::iterator it;
00204 map<double, CDart*>::iterator it2;
00205
00206 CDart* first=NULL;
00207 CDart* prec=NULL;
00208 CVertex vectNormal(0, 0, 1);
00209 CVertex vect1, vect2, sommet;
00210
00211 for (unsigned int i = 0; i < initVertices.size(); ++i)
00212 {
00213 it = testVertices[i].begin();
00214 if (it != testVertices[i].end())
00215 {
00216
00217
00218 tabDart.clear();
00219 first = *it;
00220
00221 sommet = *findVertex(*it);
00222 vect1 = *findVertex(alpha0(*it)) - sommet;
00223 ++it;
00224 while (it != testVertices[i].end())
00225 {
00226 vect2 = *findVertex(alpha0(*it)) - sommet;
00227 tabDart.insert
00228 (pair<double, CDart*>
00229 (positifAngle(CGeometry::getAngle(vect1, vect2, vectNormal)),
00230 *it));
00231 ++it;
00232 }
00233
00234
00235 it2 = tabDart.begin();
00236 prec = first;
00237 while (it2 != tabDart.end())
00238 {
00239 sew1(prec, alpha2(it2->second));
00240 prec = it2->second;
00241 ++it2;
00242 }
00243 sew1(prec, alpha2(first));
00244 }
00245 }
00246
00247
00248 return first;
00249 }
00250
00251 CDart* CGMapVertex::addEdgeOFF(vector< CVertex >& AInitVertices,
00252 unsigned int AV1, unsigned int AV2,
00253 int AIndex, CDart* APrec)
00254 {
00255 CDart* dart1 = addMapDart(AInitVertices[AV1]);
00256 CDart* dart2 = addMapDart();
00257
00258 setDirectInfo(dart1, AIndex, (void*)AV1);
00259 setDirectInfo(dart2, AIndex, (void*)AV2);
00260
00261
00262 linkAlpha0(dart1, dart2);
00263
00264 linkAlpha3(dart1, addMapDart());
00265 linkAlpha3(dart2, addMapDart());
00266 linkAlpha0(alpha3(dart1), alpha3(dart2));
00267
00268 setDirectInfo(alpha3(dart1), AIndex, (void*)AV1);
00269 setDirectInfo(alpha3(dart2), AIndex, (void*)AV2);
00270
00271 if (APrec != NULL)
00272 {
00273 linkAlpha1(APrec, dart1);
00274 linkAlpha1(alpha3(APrec), alpha3(dart1));
00275 }
00276
00277 return dart2;
00278 }
00279
00280 CDart* CGMapVertex::importOff3D(std::istream & AStream)
00281 {
00282
00283 vector< CVertex > initVertices;
00284 vector< list<CDart*> > testVertices;
00285
00286 string txt;
00287 TCoordinate x, y, z;
00288 CDart *prec = NULL, *first = NULL;
00289 unsigned int i, n, v1, v2, vf;
00290
00291 AStream >> txt;
00292 if (txt != "OFF" && txt != "OFF3D")
00293 {
00294 cout << "Problème d'entête : fichier non OFF" << endl;
00295 return NULL;
00296 }
00297
00298 unsigned int nbSommets = 0;
00299 unsigned int nbFaces = 0;
00300 unsigned int doubleNbAretes = 0;
00301
00302 AStream >> nbSommets >> nbFaces >> doubleNbAretes;
00303 while (nbSommets > 0)
00304 {
00305 if (!AStream.good())
00306 {
00307 cout << "Problème de lecture : pas assez de sommets" << endl;
00308 return NULL;
00309 }
00310
00311 AStream >> x >> y >> z;
00312 initVertices.push_back(CVertex(x, y, z));
00313 testVertices.push_back(list<CDart*>());
00314 --nbSommets;
00315 }
00316
00317 int index = getNewDirectInfo();
00318
00319 while (nbFaces > 0)
00320 {
00321 if (!AStream.good())
00322 {
00323 cout << "Problème de lecture : pas assez de faces" << endl;
00324 freeDirectInfo(index);
00325 return NULL;
00326 }
00327
00328
00329 AStream >> n;
00330 prec = NULL;
00331 first = NULL;
00332
00333
00334 AStream >> v1; --n;
00335 vf = v1;
00336 assert(v1 < initVertices.size());
00337
00338
00339 for (i = 0;i < n;++i)
00340 {
00341 AStream >> v2;
00342 assert(v2 < initVertices.size());
00343
00344 prec = addEdgeOFF(initVertices, v1, v2, index,
00345 prec);
00346
00347 if (first == NULL) first = alpha0(prec);
00348
00349 v1 = v2;
00350 }
00351 AStream.ignore(256,'\n');
00352
00353 prec = addEdgeOFF(initVertices, v1, vf, index,
00354 prec);
00355
00356 linkAlpha1(first, prec);
00357 linkAlpha1(alpha3(first), alpha3(prec));
00358
00359 linkFaceAlpha2OFF(testVertices, index, first);
00360
00361 --nbFaces;
00362 }
00363
00364 freeDirectInfo(index);
00365
00366 return first;
00367 }
00368
00369 int CGMapVertex::getOffDimension(const char * AFilename)
00370 {
00371 ifstream stream;
00372 stream.open(AFilename);
00373 string txt;
00374 stream >> txt;
00375 stream.close();
00376
00377 if (txt == "OFF2D") return 2;
00378 else if (txt == "OFF" || txt == "OFF3D") return 3;
00379
00380 return -1;
00381 }
00382
00383 CDart* CGMapVertex::importOff(const char * AFilename)
00384 {
00385 ifstream stream;
00386 stream.open(AFilename);
00387 int dim = getOffDimension(AFilename);
00388
00389 switch (dim)
00390 {
00391 case 2: return importOff2D(stream); break;
00392 case 3: return importOff3D(stream); break;
00393 }
00394 return NULL;
00395 }
00396
00397 bool CGMapVertex::exportOff2D(std::ostream & AStream)
00398 {
00399 CDynamicCoverageAll it(this);
00400
00401
00402 int directInfoIndex = getNewDirectInfo();
00403 int markVertex = getNewMark();
00404 int markEdge = getNewMark();
00405 unsigned int nbV = 0;
00406 unsigned int nbE = 0;
00407 for (it.reinit(); it.cont(); ++it)
00408 {
00409 if (!isMarked(*it, markVertex))
00410 {
00411 for (CBasicDynamicCoverageVertex it2(this, *it, markVertex);
00412 it2.cont(); ++it2)
00413 setDirectInfo(*it2, directInfoIndex, (void*)nbV);
00414 ++nbV;
00415 }
00416 if (!isMarked(*it, markEdge))
00417 {
00418 markOrbit(*it, ORBIT_EDGE, markEdge);
00419 ++nbE;
00420 }
00421 }
00422
00423
00424 AStream << "OFF2D" << endl;
00425 AStream << nbV << " " << nbE << endl;
00426 AStream << endl;
00427
00428
00429 negateMaskMark(markVertex);
00430 for (it.reinit(); it.cont(); ++it)
00431 {
00432 if (!isMarked(*it, markVertex))
00433 {
00434 CVertex* v = findVertex(*it);
00435 AStream << v->getX() << " " << v->getY() << endl;
00436 markOrbit(*it, ORBIT_VERTEX, markVertex);
00437 }
00438 }
00439
00440 AStream << endl;
00441
00442
00443 negateMaskMark(markEdge);
00444 for (it.reinit(); it.cont(); ++it)
00445 {
00446 if (!isMarked(*it, markEdge))
00447 {
00448 AStream << (unsigned int)getDirectInfo(*it, directInfoIndex)
00449 << " " << (unsigned int)getDirectInfo(alpha0(*it),
00450 directInfoIndex) << endl;
00451 markOrbit(*it, ORBIT_EDGE, markEdge);
00452 }
00453 }
00454
00455 negateMaskMark(markVertex); freeMark(markVertex);
00456 negateMaskMark(markEdge); freeMark(markEdge);
00457 freeDirectInfo(directInfoIndex);
00458
00459 return true;
00460 }
00461
00462 bool CGMapVertex::exportOff3D(std::ostream & AStream)
00463 {
00464 CDynamicCoverageAll it(this);
00465
00466
00467 int directInfoIndex = getNewDirectInfo();
00468 int markVertex = getNewMark();
00469 int markFace = getNewMark();
00470 unsigned int nbV = 0;
00471 unsigned int nbE = 0;
00472 unsigned int nbF = 0;
00473
00474 for (it.reinit(); it.cont(); ++it)
00475 {
00476 if (!isMarked(*it, markVertex))
00477 {
00478 for (CBasicDynamicCoverageVertex it2(this, *it, markVertex);
00479 it2.cont(); ++it2)
00480 setDirectInfo(*it2, directInfoIndex, (void*)nbV);
00481 ++nbV;
00482 }
00483 if (!isMarked(*it, markFace))
00484 {
00485 markOrbit(*it, ORBIT_FACE, markFace);
00486 ++nbF;
00487 }
00488 }
00489
00490
00491 AStream << "OFF" << endl;
00492 AStream << nbV << " " << nbF << " " << nbE << endl;
00493 AStream << endl;
00494
00495
00496 negateMaskMark(markVertex);
00497 for (it.reinit(); it.cont(); ++it)
00498 {
00499 if (!isMarked(*it, markVertex))
00500 {
00501 CVertex* v = findVertex(*it);
00502 AStream << v->getX() << " " << v->getY() << " " << v->getZ() << endl;
00503 markOrbit(*it, ORBIT_VERTEX, markVertex);
00504 }
00505 }
00506
00507 AStream << endl;
00508
00509
00510 negateMaskMark(markFace);
00511 for (it.reinit(); it.cont(); ++it)
00512 {
00513 if (!isMarked(*it, markFace))
00514 {
00515 CDynamicCoverage01 itFace(this,*it);
00516 int n=0; bool faceOuverte = false;
00517 for (; !faceOuverte && itFace.cont(); ++itFace)
00518 {
00519 if (isFree0(*it)||isFree1(*it)) faceOuverte=true;
00520 ++n;
00521 }
00522
00523 if ( !faceOuverte )
00524 {
00525
00526 AStream << (n/2) <<" ";
00527 itFace.reinit();
00528 while( itFace.cont() )
00529 {
00530 AStream << (unsigned int)getDirectInfo(*itFace, directInfoIndex)
00531 << " ";
00532
00533 setMark(alpha3(*itFace), markFace);
00534 setMark(itFace++, markFace); assert(itFace.cont());
00535
00536 setMark(alpha3(*itFace), markFace);
00537 setMark(itFace++, markFace);
00538 }
00539 AStream << endl;
00540 }
00541 else
00542 markOrbit(*it, ORBIT_FACE, markFace);
00543 }
00544 }
00545
00546 negateMaskMark(markVertex); freeMark(markVertex);
00547 negateMaskMark(markFace); freeMark(markFace);
00548 freeDirectInfo(directInfoIndex);
00549
00550 return true;
00551 }
00552
00553 bool CGMapVertex::exportOff(const char * AFilename)
00554 {
00555 ofstream stream;
00556 stream.open(AFilename, ios::trunc);
00557
00558 int dim = getMapDimension();
00559 bool res = false;
00560
00561 if ( dim==3 ) res = exportOff3D(stream);
00562 else res = exportOff2D(stream);
00563
00564 stream.close();
00565 return res;
00566 }
00567
00568 bool CGMapVertex::exportOff3D(const char * AFilename)
00569 {
00570 ofstream stream;
00571 stream.open(AFilename, ios::trunc);
00572
00573 bool res = exportOff3D(stream);
00574
00575 stream.close();
00576 return res;
00577 }
00578