Moka controler: src/lib-controler-gmap/controler-gmap-export-xfig.cc Source File

00001 /*
00002  * lib-controler-gmap : Le contrôleur de 3-G-cartes, surcouche de lib-controler.
00003  * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
00004  *               http://www.sic.sp2mi.univ-poitiers.fr/
00005  * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
00006  *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
00007  *
00008  * This file is part of lib-controler-gmap
00009  *
00010  * This program is free software: you can redistribute it and/or modify
00011  * it under the terms of the GNU Lesser General Public License as published by
00012  * the Free Software Foundation, either version 3 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public License
00021  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00022  */
00023 
00024 #include <cmath>
00025 #include <cstring>
00026 #include "controler-gmap.hh"
00027 #include "view-precompile.hh"
00028 #include "g-map-vertex.hh"
00029 using namespace std;
00030 using namespace GMap3d;
00031 
00032 #define RINT(V) ((double) ((int) (V)))
00033 /*************************************************/
00034 
00035 static TViewId FViewId;
00036 
00037 bool drawArrows;
00038 bool drawFaces;
00039 bool drawSews;
00040 bool drawGrid;
00041 bool drawVertices;
00042 
00043 /*************************************************/
00044 
00045 static TCoordinate k0; // coefficients for draw the sew
00046 static TCoordinate kw[4];
00047 static TCoordinate decalageX, decalageY; // the decalage offset in 2D
00048 static TCoordinate coefMultProf;
00049 static TCoordinate profMin;
00050 static bool invertY = true;
00051 
00052 //******************************************************************************
00053 // Windows/mapGlXfig.inc
00054 int MAX_PROF         =999;  // profondeur max accepte par xfig
00055 
00056 int COUL_DART        =0; //le numero de la couleur perso associe aux divers elements
00057 
00058 int COUL_SEW[4]      ={1,2,3,4};
00059 
00060 int COUL_DART_NO_SEW0=5;
00061 
00062 int COUL_SEL [NB_SELECTION_LEVELS] = { 6 ,  7 ,  8 };
00063 int COUL_LAST[NB_SELECTION_LEVELS] = { 9 , 10 , 11 };
00064 
00065 int COUL_VERTEX       =12;
00066 int COUL_GRID         =13;
00067 int COUL_AXE_X        =14;
00068 int COUL_AXE_Y        =15;
00069 int COUL_AXE_Z        =16;
00070 int COUL_FILL_FACE    =17;
00071 int COUL_POINTEL      =18;
00072 int COUL_LIGNEL       =19;
00073 int COUL_DART_VERTEX  =20;
00074 
00075 int LARG_DART         =1; //largeurs des lignes des divers elements
00076 int LARG_SEL [NB_SELECTION_LEVELS] = {1,1,1};
00077 int LARG_LAST[NB_SELECTION_LEVELS] = {2,2,2};
00078 int LARG_SEW[4]       ={1,1,1,1};
00079 int LARG_GRID         =1;
00080 int LARG_AXE_X        =1;
00081 int LARG_AXE_Y        =1;
00082 int LARG_AXE_Z        =1;
00083 int LARG_FILL_FACE    =1;
00084 int RAYON_POINTEL     =5;
00085 int LARG_LIGNEL       =3;
00086 int RAYON_DART_VERTEX =3;
00087 float COEF_REDUC_LIGNEL=0.75; // coefficient pour homotethie des lignels
00088 int COEF_DE_REDUCTION=5;      // Car sinon le dessin xfig est beaucoup trop gros
00089 float RAYON =100/COEF_DE_REDUCTION; // rayon d'un brin non cousu par alpha0
00090 int NB_COUL_USER=21; // Doit être > à 15
00091 typedef char coulXfig[8];
00092 coulXfig * COUL_USER= NULL;
00093 
00094 //******************************************************************************
00095 void CControlerGMap::initConfig()
00096 {
00097   assert(NB_COUL_USER>15);
00098 
00099   if ( COUL_USER!=NULL ) delete COUL_USER;
00100   
00101   COUL_USER=new coulXfig[NB_COUL_USER];
00102   for (int i=0;i<NB_COUL_USER;++i) strcpy(COUL_USER[i],"#000000");
00103   strcpy(COUL_USER[               1],"#808080"); // 0-coutures
00104   strcpy(COUL_USER[               2],"#FF0000"); // 1-coutures
00105   strcpy(COUL_USER[               3],"#008000"); // 2-coutures
00106   strcpy(COUL_USER[               4],"#0000FF"); // 3-coutures
00107   strcpy(COUL_USER[  COUL_FILL_FACE],"#DDDDDD"); // faces pleines
00108   strcpy(COUL_USER[COUL_DART_VERTEX],"#A0A0A0"); // points associés aux brins
00109 }
00110 
00111 //******************************************************************************
00112 void CControlerGMap::transfoMmPixel( CVertex & v2d )
00113 {
00114   // Xfig est en 1200 dpi, et donc le nombre de pixel par mm vaut 1200/25.4
00115   // (sachant que 1inch==25.4mm)
00116   float dpmX=(1200/25.4);
00117   float dpmY=(1200/25.4);
00118   v2d.setX(static_cast<TCoordinate>((v2d.getX()*dpmX)/COEF_DE_REDUCTION));
00119   v2d.setY(static_cast<TCoordinate>((v2d.getY()*dpmY)/COEF_DE_REDUCTION));
00120 }
00121 
00122 //******************************************************************************
00123 void CControlerGMap::sauveEntete ( ofstream &os, int nbCoul )
00124 {
00125   os<<"#FIG 3.2"<<endl
00126     <<"Portrait"<<endl
00127     <<"Metric"<<endl
00128     <<"A4"<<endl
00129     <<"100.00"<<endl
00130     <<"Single"<<endl
00131     <<"-2"<<endl
00132     <<"1200 2"<<endl;
00133   // Ici, on definit des couleurs personelles. Cela permet ensuite de
00134   // changer une valeur et cela entraine la modif de tous les brins
00135   // ayant cette couleur.
00136   
00137   initConfig();
00138   
00139   if (COUL_USER==NULL)
00140     for (int i=0;i<nbCoul;++i) os<<"0 "<<32+i<<" #000000"<<endl;
00141   else
00142     for (int i=0;i<nbCoul;++i) os<<"0 "<<32+i<<" "<<COUL_USER[i]<<endl;
00143 }
00144 //******************************************************************************
00145 void CControlerGMap::debutComposante( ofstream &os,
00146                                   const CVertex & min, const CVertex & max )
00147 {
00148   os<<"6 "
00149     <<int(RINT(min.getX()+decalageX))<<" "
00150     <<int(RINT(min.getY()+decalageY))<<" "
00151     <<int(RINT(max.getX()+decalageX))<<" "
00152     <<int(RINT(max.getY()+decalageY))<<endl;
00153 }
00154 
00155 //******************************************************************************
00156 int CControlerGMap::computeProf(const CVertex & V)
00157 {
00158   int p = int(RINT(coefMultProf*(V.getZ()-profMin)));
00159 
00160   if (p<0)
00161     p=0;
00162 
00163   if (p>MAX_PROF)
00164     p=MAX_PROF;
00165 
00166   return p;
00167 }
00168 
00169 int CControlerGMap::computeProf(const CVertex & V1, const CVertex & V2)
00170 {
00171   TCoordinate c = (V1.getZ() + V2.getZ())/2;
00172   
00173   int p = int(RINT(coefMultProf*(c-profMin)));
00174   
00175   if (p<0)
00176     p=0;
00177 
00178   if (p>MAX_PROF)
00179     p=MAX_PROF;
00180 
00181   return p;
00182 }
00183 //******************************************************************************
00184 void CControlerGMap::sauvePoint(ofstream &os, const CVertex & v,
00185                                 int coul, int larg)
00186 {
00187   os<<"1 4 0 "<<larg<<" "<<32+coul<<" "<<32+coul<<" "
00188     <<computeProf(v)<<" 0 20 0.000 1 0.0000 ";
00189 
00190   os<<int(RINT(v.getX()+decalageX))<<" "  // Centre x et y
00191     <<int(RINT(v.getY()+decalageY))<<" "
00192     <<RAYON<<" "<<RAYON<<" " //Rayon en x et en y
00193     <<int(RINT(v.getX()+decalageX))<<" "  // Premier point == centre
00194     <<int(RINT(v.getY()+decalageY))<<" "
00195     <<int(RINT(v.getX()+decalageX+RAYON))<<" " // deuxieme point (sur le cercle)
00196     <<int(RINT(v.getY()+decalageY+RAYON))<<endl;
00197 }
00198 //******************************************************************************
00199 void CControlerGMap::sauveDartVertex(std::ofstream &os, const CVertex & v,
00200                                      const CVertex & /*v2*/)
00201 {
00202   int prof = MAX_PROF;
00203   
00204   os<<"1 3 0 "<<RAYON_DART_VERTEX<<" "<<32+COUL_DART_VERTEX
00205     <<" "<<32+COUL_DART_VERTEX<<" "<<prof<<" 0 20 0.000 1 0.0000 ";
00206 
00207   os<<int(RINT(v.getX()+decalageX))<<" "  // Centre x et y
00208     <<int(RINT(v.getY()+decalageY))<<" "
00209     <<RAYON<<" "<<RAYON<<" " //Rayon en x et en y
00210     <<int(RINT(v.getX()+decalageX))<<" "  // Premier point == centre
00211     <<int(RINT(v.getY()+decalageY))<<" "
00212     <<int(RINT(v.getX()+decalageX+RAYON))<<" " // deuxieme point (sur le cercle)
00213     <<int(RINT(v.getY()+decalageY+RAYON))<<endl;
00214 }
00215 //******************************************************************************
00216 void CControlerGMap::sauveLine(ofstream &os,
00217                                const CVertex & p1, const CVertex & p2,
00218                                int coul, int larg, bool arrow, int AProf)
00219 {
00220   int prof;
00221 
00222   if (AProf<0)
00223     prof = computeProf(p1,p2);
00224   else
00225     prof = AProf;
00226 
00227   os<<"2 1 0 "<<larg<<" "<<32+coul<<" 0 "<< prof <<" 0 -1 0.000 1 0 7 ";
00228   if (arrow)
00229     {
00230       os<<"1 0 2\n"
00231         <<"     2 0 1.00 60.00 120.00\n";
00232     }
00233   else
00234     os<<"0 0 2\n";
00235 
00236   os<<int(RINT(p1.getX()+decalageX))<<" "
00237     <<int(RINT(p1.getY()+decalageY))<<" "
00238     <<int(RINT(p2.getX()+decalageX))<<" "
00239     <<int(RINT(p2.getY()+decalageY))<<endl;
00240 }
00241 
00242 //******************************************************************************
00243 void CControlerGMap::sauveTriangle(ofstream & os, int coulFill, int larg,
00244                                    CVertex & PC, CVertex & P1, CVertex & P2)
00245 {
00246   os << "2 1 0 " << larg << " -1 "
00247      << 32+coulFill << " "
00248      << (1+computeProf((PC+P1+P2)/3)) << " 0 20 0.000 1 0 7 0 0 " << 4 << endl;
00249 
00250   os << int(RINT(PC.getX()+decalageX)) << " "
00251      << int(RINT(PC.getY()+decalageY)) << endl;
00252   os << int(RINT(P1.getX()+decalageX)) << " "
00253      << int(RINT(P1.getY()+decalageY)) << endl;
00254   os << int(RINT(P2.getX()+decalageX)) << " "
00255      << int(RINT(P2.getY()+decalageY)) << endl;
00256   os << int(RINT(PC.getX()+decalageX)) << " "
00257      << int(RINT(PC.getY()+decalageY)) << endl;
00258 }
00259 //******************************************************************************
00260 void CControlerGMap::sauveFace(ofstream &os, CVertex *p, int nbPts,
00261                                int coulFill, int larg )
00262 {
00263   assert(nbPts>=3); // 3 => polygone à 2 arêtes...
00264 
00265   CVertex baryFace;
00266   int i;
00267 
00268   for (i=0; i<nbPts-1; ++i)
00269     baryFace += p[i];
00270 
00271   baryFace /= nbPts-1;
00272 
00273   bool compactFaces = isZero(FMap->getBurstCoef(1) - 1.0);
00274 
00275   os<<"2 1 0 " << (compactFaces&&!drawArrows?larg:0) << " "
00276     << 32+COUL_DART << " " << 32+coulFill << " "
00277     << (1+computeProf(baryFace)) <<" 0 20 0.000 1 0 7 0 0 "
00278     << nbPts << endl;
00279 
00280   for (i=0; i<nbPts; ++i)
00281     {      
00282       os << int(RINT(p[i].getX()+decalageX)) << " "
00283          << int(RINT(p[i].getY()+decalageY)) << endl;
00284     }
00285   
00286   /* Ancienne version de Fred qui sauvait des triangles => pb de profondeur... */
00287   /*
00288     CVertex baryFace;
00289   int i;
00290 
00291   for (i=0; i<nbPts-1; ++i)
00292     baryFace += p[i];
00293 
00294   baryFace /= nbPts-1;
00295 
00296   bool compactFaces = isZero(FMap->getBurstCoef(1) - 1.0);
00297 
00298   for (i=0; i<nbPts-1; ++i)
00299     {
00300       if (compactFaces || (i%2==0))
00301         {
00302           CVertex baryEdge = (p[i]+p[i+1])/2;
00303 
00304           sauveTriangle(os, coulFill, larg, baryFace, p[i]    , baryEdge);
00305           sauveTriangle(os, coulFill, larg, baryFace, baryEdge, p[i+1]  );
00306         }
00307 
00308       if (!compactFaces && (i%2==1))
00309         sauveTriangle(os, coulFill, larg, baryFace, p[i], p[i+1]);
00310 
00311        }
00312   */
00313 }
00314 
00315 //******************************************************************************
00316 void CControlerGMap::transfo3dTo2d( const CVertex & v3d, CVertex & v2d )
00317 {
00318   float res[3];
00319 
00320   FViews[FViewId]->project( v3d.getX(), v3d.getY(), v3d.getZ(), res);
00321                          
00322   v2d.setX(res[0]); v2d.setY(res[1]); v2d.setZ(res[2]);
00323 
00324   transfoMmPixel(v2d);
00325 
00326   if (invertY) v2d.setY(-v2d.getY());
00327 }
00328 
00329 //******************************************************************************
00330 void CControlerGMap::updateMinMax2d( const CVertex & pts,
00331                                      CVertex & min, CVertex & max, bool init )
00332 {
00333   CVertex tmp;
00334   transfo3dTo2d(pts,tmp);
00335 
00336   if (init)
00337     { min=tmp; max=tmp; }
00338   else
00339     {
00340       if (tmp.getX()<min.getX()) min.setX(tmp.getX());
00341       if (tmp.getY()<min.getY()) min.setY(tmp.getY());
00342       if (tmp.getZ()<min.getZ()) min.setZ(tmp.getZ());
00343       if (tmp.getX()>max.getX()) max.setX(tmp.getX());
00344       if (tmp.getY()>max.getY()) max.setY(tmp.getY());
00345       if (tmp.getZ()>max.getZ()) max.setZ(tmp.getZ());
00346     }
00347 }
00348 
00349 //******************************************************************************
00350 void CControlerGMap::getIncludingBoxForDarts( CDart* d, TOrbit orb,
00351                                               CVertex & min, CVertex & max )
00352 {
00353   CCoverage* cov = FMap->getDynamicCoverage(d,orb);
00354 
00355   if (cov->cont())
00356     {
00357       transfo3dTo2d(FMap->getBurstVertex(d),min);
00358       max=min;
00359       ++(*cov);
00360     }
00361 
00362   while(cov->cont())
00363     {
00364       updateMinMax2d(FMap->getBurstVertex(**cov),min,max);
00365       ++(*cov);
00366     }
00367 
00368   delete cov;
00369 }
00370 
00371 #define WEIGHTING(k, v1,v2) ( (1-(k)) * (v1) + (k) * (v2) )
00372 //******************************************************************************
00373 void CControlerGMap::treatSews( ofstream & fout, CDart * dart,
00374                                 int mark, int /*mark2*/ )
00375 {
00376   CDart *darti;
00377   CVertex vTmp, v2Tmp, v3Tmp, p1, p2;
00378 
00379   for (int i=0; i<=3; ++i)
00380     if (!FMap->isMarked(FMap->alpha(dart,i),mark))
00381       {
00382         darti= FMap->alpha(dart,i);
00383         if (!FMap->isFree(dart,i) &&
00384             getParameterSew(FViewId)->getDisplayAlpha(i))
00385           {
00386             if (i==0)
00387               {
00388                 transfo3dTo2d(FMap->getBurstVertex(dart ), p1);
00389                 transfo3dTo2d(FMap->getBurstVertex(darti), p2);
00390 
00391                 vTmp = (p1+p2)/2;
00392 
00393                 int prof1 = computeProf(p1, vTmp);
00394                 int prof2 = computeProf(p2, vTmp);
00395 
00396                 int prof = prof1<prof2 ? prof1 : prof2;
00397 
00398                 if (prof<0) prof=0;
00399                 if (prof>MAX_PROF) prof=MAX_PROF;
00400 
00401                 vTmp = (FMap->getBurstVertex(dart) +
00402                         FMap->getBurstVertex(darti))/2;
00403 
00404                 v2Tmp=WEIGHTING(kw[0],vTmp, FMap->computeBurstExtremity(dart ));
00405                 v3Tmp=WEIGHTING(kw[0],vTmp, FMap->computeBurstExtremity(darti));
00406                 transfo3dTo2d(v2Tmp,p1);
00407                 transfo3dTo2d(v3Tmp,p2);
00408 
00409                 sauveLine(fout,p1,p2,COUL_SEW[i],LARG_SEW[i],false, prof);
00410               }
00411             else
00412               {
00413                 if ( FMap->isFree0(dart) || kw[i]!=1 || dart<FMap->alpha0(dart) )
00414                   {
00415                     vTmp =WEIGHTING(kw[i],FMap->getBurstVertex(dart ),
00416                                     FMap->computeBurstExtremity(dart ));
00417                     v2Tmp=WEIGHTING(kw[i],FMap->getBurstVertex(darti),
00418                                     FMap->computeBurstExtremity(darti));
00419                     transfo3dTo2d(v2Tmp,p1);
00420                     transfo3dTo2d(vTmp,p2);
00421                     
00422                     sauveLine(fout,p1,p2,COUL_SEW[i],LARG_SEW[i],false);
00423                   }
00424               }
00425           }
00426       }
00427 }
00428 
00429 //******************************************************************************
00430 void CControlerGMap::treatDartWithArrow( ofstream & fout, CDart * dart,
00431                                          int /*mark*/, int mark2 )
00432 {
00433   CVertex v1;
00434   CVertex v2,p1,p2;
00435   int coul = COUL_DART;
00436   int larg = LARG_DART;
00437 
00438   v1= FMap->getBurstVertex(dart);
00439   transfo3dTo2d(v1, p1);
00440 
00441   if (FMap->isFree0(dart))
00442     sauvePoint(fout,p1,COUL_DART_NO_SEW0,LARG_DART);
00443   else
00444     {
00445       CDart *dart0=FMap->alpha0(dart);
00446 
00447       bool found = false;
00448       int i;
00449 
00450       for (i=0; !found && i<getNbSelectionLevels(); ++i)
00451         if (dart==getLastSelectedDart(i) || dart0==getLastSelectedDart(i))
00452           {
00453             coul=COUL_LAST[i];
00454             larg=LARG_LAST[i];
00455             found = true;
00456           }
00457 
00458       for (i=0; !found && i<getNbSelectionLevels(); ++i)
00459         if (isDartSelected(dart,i) || isDartSelected(dart0, i))
00460           {
00461             coul=COUL_SEL[i];
00462             larg=LARG_SEL[i];
00463             found = true;
00464           }
00465 
00466       v1= FMap->getBurstVertex(dart0);
00467       transfo3dTo2d(v1, p2);
00468 
00469       if (FMap->isMarked(dart,mark2))
00470         {
00471           sauveLine(fout,p1,p2,coul,larg,true);
00472           if ( drawVertices )
00473             sauveDartVertex( fout, p1, p2 );
00474         }
00475       else
00476         {
00477           sauveLine(fout,p2,p1,coul,larg,true);
00478           if ( drawVertices )
00479             sauveDartVertex( fout, p2, p1 );
00480         }
00481     }
00482 }
00483 
00484 //******************************************************************************
00485 void CControlerGMap::treatDartNoArrow( ofstream & fout, CDart * dart,
00486                                        int /*mark*/, int /*mark2*/ )
00487 {
00488   CVertex v1;
00489   CVertex v2,p1,p2;
00490   int coul = COUL_DART;
00491   int larg = LARG_DART;
00492 
00493   bool found = false;
00494   int i;
00495 
00496   for (i=0; !found && i<getNbSelectionLevels(); ++i)
00497     if (dart==getLastSelectedDart(i))
00498       {
00499         coul=COUL_LAST[i];
00500         larg=LARG_LAST[i];
00501         found = true;
00502       }
00503 
00504   for (i=0; !found && i<getNbSelectionLevels(); ++i)
00505     if (isDartSelected(dart,i))
00506       {
00507         coul=COUL_SEL[i];
00508         larg=LARG_SEL[i];
00509         found = true;
00510       }
00511 
00512   v1= FMap->getBurstVertex(dart);
00513   transfo3dTo2d(v1, p1);
00514 
00515   if (FMap->isFree0(dart))
00516     sauvePoint(fout,p1,COUL_DART_NO_SEW0,LARG_DART);
00517   else
00518     {
00519       CDart *dart0 = FMap->alpha0(dart);
00520 
00521       transfo3dTo2d(FMap->getBurstVertex(dart ), p1);
00522       transfo3dTo2d(FMap->getBurstVertex(dart0), p2);
00523       CVertex p0 = (p1+p2)/2;
00524 
00525       v2=FMap->computeBurstExtremity(dart);
00526       transfo3dTo2d(v2, p2);
00527       sauveLine(fout,p1,p2,coul,larg,false, computeProf(p1,p0));
00528 
00529       coul=COUL_DART; larg=LARG_DART;
00530 
00531       bool found = false;
00532       int i;
00533 
00534       for (i=0; !found && i<getNbSelectionLevels(); ++i)
00535         if (dart0==getLastSelectedDart(i))
00536           {
00537             coul=COUL_LAST[i];
00538             larg=LARG_LAST[i];
00539             found = true;
00540           }
00541 
00542       for (i=0; !found && i<getNbSelectionLevels(); ++i)
00543         if (isDartSelected(dart0,i))
00544           {
00545             coul=COUL_SEL[i];
00546             larg=LARG_SEL[i];
00547             found = true;
00548           }
00549 
00550       v1= FMap->getBurstVertex(dart0);
00551       transfo3dTo2d(v1, p1);
00552 
00553       v2=FMap->computeBurstExtremity(dart0);
00554       transfo3dTo2d(v2, p2);
00555       sauveLine(fout,p1,p2,coul,larg,false, computeProf(p1,p0));
00556 
00557       if ( drawVertices )
00558         sauveDartVertex( fout, p1, p2);
00559     }
00560 }
00561 
00562 //******************************************************************************
00563 void CControlerGMap::treatFace( ofstream & fout, CDart * initDart,
00564                                 int mark, int mark2 )
00565 {
00566   CDart *dart;
00567 
00568   // On parcours ici la face
00569   CDynamicCoverage01 covF(FMap,initDart);
00570   while ( covF.cont() )
00571     {
00572       if ( !FMap->isMarked(*covF,mark) ) //brin non encore parcouru
00574         {
00575           assert(!FMap->isMarked(FMap->alpha0(*covF),mark));
00576           dart=*covF;
00577 
00578           if (drawArrows) treatDartWithArrow(fout,dart,mark,mark2);
00579           else treatDartNoArrow(fout,dart,mark,mark2);
00580 
00581           if (drawSews)
00582             {
00583               treatSews(fout,dart,mark,mark2);
00584               if (!FMap->isFree0(dart))
00585                 treatSews(fout,FMap->alpha0(dart),mark,mark2);
00586             }
00587 
00588           FMap->setMark(dart,mark);
00589           FMap->setMark(FMap->alpha0(dart),mark);
00590         }
00591       ++covF;
00592     } // Fin de parcours de face
00593 }
00594 
00595 //******************************************************************************
00596 void CControlerGMap::treatFilledFace( ofstream & fout, CDart * dart,
00597                                       int mark, int mark2 )
00598 {
00599   int nbPts=0;
00600   CVertex v1;
00601 
00602   if (drawArrows && FMap->isMarked(dart,mark2))
00603     dart=FMap->alpha0(dart);
00604 
00605   // On parcours ici la face
00606   CDynamicCoverage01 covF(FMap,dart);
00607   while ( covF.cont() )
00608     {
00609       ++nbPts;
00610       if (FMap->isFree0(*covF) || FMap->isFree1(*covF))
00611         {
00612           treatFace(fout,dart,mark,mark2);  // si la face n'est pas
00613           return;               // fermée, on ne peut pas la dessiner pleine !!!
00614         }
00615       ++covF;
00616     }
00617 
00618   bool compactFaces = isZero(FMap->getBurstCoef(1) - 1.0);
00619 
00620   if (compactFaces)
00621     nbPts/=2;  //car en g carte donc on alpha compte les sommets 2 fois
00622 
00623   CVertex * tabV = new CVertex[nbPts+1];
00624   nbPts=0;
00625 
00626   for (covF.reinit(); covF.cont();)
00627     {
00628       v1= FMap->getBurstVertex(*covF);
00629       transfo3dTo2d(v1, tabV[nbPts++]);
00630 
00631       if ( compactFaces ) // Ici on marque, sinon c'est fait dans la méthode treatFace
00632         {
00633           if (drawArrows) treatDartWithArrow(fout,*covF,mark,mark2);
00634 
00635           if (drawSews)
00636             {
00637               treatSews(fout,*covF,mark,mark2);
00638               if (!FMap->isFree0(*covF))
00639                 treatSews(fout,FMap->alpha0(*covF),mark,mark2);
00640             }
00641           
00642           FMap->setMark(*covF,mark);
00643           FMap->setMark(FMap->alpha0(*covF),mark);
00644         }
00645       
00646       if (compactFaces && covF.cont())
00647         ++covF;
00648 
00649       if (covF.cont())
00650         ++covF;
00651     }
00652 
00653   tabV[nbPts++] = tabV[0];
00654 
00655   // On commence par sauver la face externe
00656   if ( !compactFaces )
00657     treatFace(fout,dart,mark,mark2);
00658   
00659   sauveFace(fout,tabV,nbPts,COUL_FILL_FACE,LARG_FILL_FACE);
00660 
00661   delete []tabV;
00662 }
00663 
00664 //******************************************************************************
00665 void CControlerGMap::saveGridIncludingBox( ofstream & fout )
00666 {
00667   CVertex v1, v2, p1, p2;
00668   CVertex min(0,0,0), max(0,0,0);
00669   bool init=true;
00670 
00671   // Axis:
00672   {
00673     // X
00674     v1=CVertex(0,0,0); updateMinMax2d(v1,min,max,init); init=false;
00675     v1=CVertex(1,0,0); updateMinMax2d(v1,min,max,init);
00676     // Y
00677     v1=CVertex(0,1,0); updateMinMax2d(v1,min,max,init);
00678     // Z
00679     v1=CVertex(0,0,1); updateMinMax2d(v1,min,max,init);
00680   }
00681         
00682   // Grid:
00683   {
00684     int  size= getParameterGrid(FViewId)->getLGGrid();
00685     bool xy  = getParameterGrid(FViewId)->getDisplayGridXY();
00686     bool xz  = getParameterGrid(FViewId)->getDisplayGridXZ();
00687     bool yz  = getParameterGrid(FViewId)->getDisplayGridYZ();
00688     bool px  = getParameterGrid(FViewId)->getDisplayPositiveGridX();
00689     bool py  = getParameterGrid(FViewId)->getDisplayPositiveGridY();
00690     bool pz  = getParameterGrid(FViewId)->getDisplayPositiveGridZ();
00691     int  xmin= px ? 0 : -size;
00692     int  ymin= py ? 0 : -size;
00693     int  zmin= pz ? 0 : -size;
00694 
00695     for (int i=-size; i<=+size; ++i)
00696       {
00697         if (xy)
00698           {
00699             /* X direction: */
00700             if (i>=0 || !py)
00701               {
00702                 v1=CVertex(xmin, i, 0); updateMinMax2d(v1,min,max,init);
00703                 init=false;
00704                 v1=CVertex(size, i, 0); updateMinMax2d(v1,min,max,init);
00705               }
00706             /* Y direction: */
00707             if (i>=0 || !px)
00708               {
00709                 v1=CVertex(i, ymin, 0); updateMinMax2d(v1,min,max,init);
00710                 init=false;
00711                 v1=CVertex(i, size, 0); updateMinMax2d(v1,min,max,init);
00712               }
00713           }
00714         if (xz)
00715           {
00716             /* X direction: */
00717             if (i>=0 || !pz)
00718               {
00719                 v1=CVertex(xmin, 0, i); updateMinMax2d(v1,min,max,init);
00720                 init=false;
00721                 v1=CVertex(size, 0, i); updateMinMax2d(v1,min,max,init);
00722               }
00723             /* Z direction: */
00724             if (i>=0 || !px)
00725               {
00726                 v1=CVertex(i, 0, zmin); updateMinMax2d(v1,min,max,init);
00727                 init=false;
00728                 v1=CVertex(i, 0, size); updateMinMax2d(v1,min,max,init);
00729               }
00730           }
00731         if (yz)
00732           {
00733             /* Y direction: */
00734             if (i>=0 || !pz)
00735               {
00736                 v1=CVertex(0, ymin, i); updateMinMax2d(v1,min,max,init);
00737                 init=false;
00738                 v1=CVertex(0, size, i);updateMinMax2d(v1,min,max,init);
00739               }
00740             /* Z direction: */
00741             if (i>=0 || !py)
00742               {
00743                 v1=CVertex(0, i, zmin); updateMinMax2d(v1,min,max,init);
00744                 init=false;
00745                 v1=CVertex(0, i, size); updateMinMax2d(v1,min,max,init);
00746               }
00747           }
00748       }
00749   }
00750 
00751   debutComposante(fout,min,max);
00752 }
00753 
00754 //******************************************************************************
00755 void CControlerGMap::treatGrid(ofstream & fout)
00756 {
00757   CVertex v1, v2, p1, p2;
00758 
00759   saveGridIncludingBox(fout);
00760 
00761   // Axis:
00762   {
00763     // X
00764     v1=CVertex(0,0,0);
00765     v2=CVertex(1,0,0);
00766     transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00767     sauveLine(fout,p1,p2,COUL_AXE_X,LARG_AXE_X,false);
00768     // Y
00769     v2=CVertex(0,1,0);
00770     transfo3dTo2d(v2,p2);
00771     sauveLine(fout,p1,p2,COUL_AXE_Y,LARG_AXE_Y,false);
00772     // Z
00773     v2=CVertex(0,0,1);
00774     transfo3dTo2d(v2,p2);
00775     sauveLine(fout,p1,p2,COUL_AXE_Z,LARG_AXE_Z,false);
00776   }
00777         
00778   // Grid:
00779   {
00780     int  size= getParameterGrid(FViewId)->getLGGrid();
00781     bool xy  = getParameterGrid(FViewId)->getDisplayGridXY();
00782     bool xz  = getParameterGrid(FViewId)->getDisplayGridXZ();
00783     bool yz  = getParameterGrid(FViewId)->getDisplayGridYZ();
00784     bool px  = getParameterGrid(FViewId)->getDisplayPositiveGridX();
00785     bool py  = getParameterGrid(FViewId)->getDisplayPositiveGridY();
00786     bool pz  = getParameterGrid(FViewId)->getDisplayPositiveGridZ();
00787     int  xmin= px ? 0 : -size;
00788     int  ymin= py ? 0 : -size;
00789     int  zmin= pz ? 0 : -size;
00790 
00791     for (int i=-size; i<=+size; ++i)
00792       {
00793         if (xy)
00794           {
00795             /* X direction: */
00796             if (i>=0 || !py)
00797               {
00798                 v1=CVertex(xmin, i, 0); v2=CVertex(size, i, 0);
00799                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00800                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00801               }
00802             /* Y direction: */
00803             if (i>=0 || !px)
00804               {
00805                 v1=CVertex(i, ymin, 0); v2=CVertex(i, size, 0);
00806                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00807                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00808               }
00809           }
00810         if (xz)
00811           {
00812             /* X direction: */
00813             if (i>=0 || !pz)
00814               {
00815                 v1=CVertex(xmin, 0, i); v2=CVertex(size, 0, i);
00816                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00817                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00818               }
00819             /* Z direction: */
00820             if (i>=0 || !px)
00821               {
00822                 v1=CVertex(i, 0, zmin); v2=CVertex(i, 0, size);
00823                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00824                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00825               }
00826           }
00827         if (yz)
00828           {
00829             /* Y direction: */
00830             if (i>=0 || !pz)
00831               {
00832                 v1=CVertex(0, ymin, i); v2=CVertex(0, size, i);
00833                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00834                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00835               }
00836             /* Z direction: */
00837             if (i>=0 || !py)
00838               {
00839                 v1=CVertex(0, i, zmin); v2=CVertex(0, i, size);
00840                 transfo3dTo2d(v1,p1); transfo3dTo2d(v2,p2);
00841                 sauveLine(fout,p1,p2,COUL_GRID,LARG_GRID,false);
00842               }
00843           }
00844       }
00845   }
00846   fout<<"-6"<<endl;
00847 }
00848 
00849 //******************************************************************************
00850 void CControlerGMap::sauveCarteXfig( TViewId AViewId, ofstream & AFout,
00851                                      bool AArrow, bool AFace, bool ASews,
00852                                      bool AGrid, bool AVertices, bool AInvert )
00853 {
00854   CVertex min, max, vTmp, v2Tmp, v3Tmp;
00855   CVertex v1;
00856 
00857   FViewId      = AViewId;
00858   drawArrows   = AArrow;
00859   drawFaces    = AFace;
00860   drawSews     = ASews;
00861   drawGrid     = AGrid;
00862   drawVertices = AVertices;
00863   invertY      = AInvert;
00864   
00865   // Initialisation for draw the sew
00866   k0 = FMap->getBurstCoef(0);
00867   for (int i=0; i<4; i++) kw[i]= getParameterSew(FViewId)->getSewPosCoef(i);
00868 
00869 //******************************************************************************
00870   sauveEntete(AFout,NB_COUL_USER);  //Nombre de couleur ?
00871   // une brin, une pour chaque couture...
00872   // Pour les 2 selections, pour les 2 last dart, ...
00873 
00874 //******************************************************************************
00875   CDynamicCoverageAll it(FMap);
00876 
00877   v1  = FMap->getBurstVertex(*it);
00878   transfo3dTo2d(v1,min);
00879   max = min;
00880 
00881   while ( it.cont() )
00882     {
00883       v1= FMap->getBurstVertex(it++);
00884       updateMinMax2d(v1,min,max);
00885     }
00886 
00887   // Here min and max define the including box in 2d of the burst map.
00888   decalageX=5-min.getX();
00889   decalageY=5-min.getY();
00890   coefMultProf=MAX_PROF/(max.getZ()-min.getZ());
00891   profMin=min.getZ();
00892 
00894   if (drawGrid)
00895     treatGrid(AFout);
00896 
00897 //******************************************************************************
00898   int mark=FMap->getNewMark();
00899   int mark2=FMap->getNewMark();  // Used for orientation
00900 
00901   it.reinit();
00902   while ( it.cont() )
00903     {
00904       if (!FMap->isMarked(*it,mark)) //brin non encore parcouru
00905         {
00906           // On parcours la composante connexe incidente
00907           CDynamicCoverage0123 cov(FMap,*it);
00908           while ( cov.cont() )
00909             {
00910               FMap->setMark(*cov,mark);
00911               if (!FMap->isMarked(FMap->alpha0(*cov),mark2) &&
00912                   !FMap->isMarked(FMap->alpha1(*cov),mark2) &&
00913                   !FMap->isMarked(FMap->alpha3(*cov),mark2) &&
00914                   !FMap->isMarked(FMap->alpha2(*cov),mark2) )
00915                 FMap->setMark(*cov,mark2);
00916               ++cov;
00917             }
00918         }
00919       ++it;
00920     }
00921 
00922   FMap->negateMaskMark(mark);
00923 
00924   // On parcours tout les brins
00925   it.reinit();
00926   while ( it.cont() )
00927     {
00928       if (!FMap->isMarked(*it,mark)) //brin non encore parcouru
00929         {
00930           // On parcours la composante connexe incidente
00931           getIncludingBoxForDarts(*it,ORBIT_0123,min,max);
00932           debutComposante(AFout,min,max);
00933 
00934           CDynamicCoverage0123 covCc(FMap,*it);
00935           while ( covCc.cont() )
00936             {
00937               if (!FMap->isMarked(*covCc,mark)) //brin non encore parcouru
00938                 {
00939                   getIncludingBoxForDarts(*covCc,ORBIT_012,min,max);
00940                   debutComposante(AFout,min,max);
00941 
00942                   // On parcours le volume incident
00943                   CDynamicCoverageVolume covV(FMap,*covCc);
00944                   while ( covV.cont() )
00945                     {
00946                       if (!FMap->isMarked(*covV,mark)) //brin non traité
00947                         {
00948                           getIncludingBoxForDarts(*covV,ORBIT_01,min,max);
00949                           debutComposante(AFout,min,max);
00950 
00951                           if (AFace)
00952                             treatFilledFace(AFout,*covV,mark,mark2);
00953                           else
00954                             treatFace(AFout,*covV,mark,mark2);
00955 
00956                           AFout<<"-6\n";  //pour fermer la composante xfig
00957                         }  //Fin du parcours d'une region
00958                       ++covV;
00959                     } // Fin du parcours d'un volume
00960                   AFout<<"-6\n";  //pour fermer la composante xfig
00961                 }
00962               ++covCc;
00963             } // Fin du parcours de tout
00964           AFout<<"-6\n";  //pour fermer la composante xfig
00965         }
00966       ++it;
00967     }
00968 
00969   FMap->negateMaskMark(mark);
00970   FMap->freeMark(mark);
00971   FMap->unmarkAll(mark2);
00972   FMap->freeMark(mark2);
00973 }
00974 //******************************************************************************
00975 void CControlerGMap::treatPointel(ofstream &os, CDart *d, int mark)
00976 {
00977   CDynamicCoverage123 it(FMap,d);
00978   while(it.cont()) FMap->setMark(it++,mark);
00979 
00980   CVertex *v1 = FMap->findVertex(d);
00981 
00982   CVertex p1;
00983   transfo3dTo2d(*v1, p1);
00984 
00985   sauvePoint(os,p1,COUL_POINTEL,RAYON_POINTEL);
00986 }
00987 //******************************************************************************
00988 void CControlerGMap::treatLignel(ofstream &os, CDart *d, int mark)
00989 {
00990   CDynamicCoverage023 it(FMap,d);
00991   while(it.cont()) FMap->setMark(it++,mark);
00992 
00993   CVertex *v1 = FMap->findVertex(d);
00994   CVertex *v2 = FMap->findVertex(FMap->alpha0(d));
00995 
00996   CVertex edgeBary= (*v1 + *v2)/2;
00997 
00998   CVertex p1 = edgeBary + COEF_REDUC_LIGNEL*(*v1-edgeBary);
00999   CVertex p2 = edgeBary + COEF_REDUC_LIGNEL*(*v2-edgeBary);
01000 
01001   CVertex pp1, pp2;
01002   transfo3dTo2d(p1, pp1);
01003   transfo3dTo2d(p2, pp2);
01004 
01005   sauveLine(os,pp1,pp2,COUL_LIGNEL,LARG_LIGNEL,false);
01006 }
01007 //******************************************************************************
01008 //  Ici on sauve toujours en face pleine, sans fleche, mais avec les
01009 //  elements intervoxels, cad les lignels et les pointels, et sans
01010 //  coutures.
01011 void CControlerGMap::sauveCarteIntervoxelXfig( TViewId AViewId,
01012                                                ofstream & AFout,
01013                                                bool AInvert )
01014 {
01015   CVertex min, max, vTmp, v2Tmp, v3Tmp;
01016   CVertex v1;
01017 
01018   FViewId = AViewId;
01019   invertY = AInvert;
01020 
01021   k0= FMap->getBurstCoef(0);
01022 
01023   drawArrows = false;
01024   
01025 //******************************************************************************
01026   sauveEntete(AFout,NB_COUL_USER);  //Nombre de couleur ?
01027   // une brin, une pour chaque couture...
01028   // Pour les 2 selections, pour les 2 last dart, ...
01029 
01030 //******************************************************************************
01031   CDynamicCoverageAll it(FMap);
01032 
01033   v1= FMap->getBurstVertex(*it);
01034   transfo3dTo2d(v1,min);
01035   max=min;
01036 
01037   while ( it.cont() )
01038     {
01039       v1= FMap->getBurstVertex(it++);
01040       updateMinMax2d(v1,min,max);
01041     }
01042 
01043   // Here min and max define the including box in 2d of the burst map.
01044   decalageX=5-min.getX();
01045   decalageY=5-min.getY();
01046   coefMultProf=MAX_PROF/(max.getZ()-min.getZ());
01047   profMin=min.getZ();
01048 
01049 //******************************************************************************
01050   int mark  = FMap->getNewMark();
01051   int mark2 = FMap->getNewMark();
01052   int mark3 = FMap->getNewMark();
01053 
01054   // On parcours tout les brins
01055   it.reinit();
01056   while ( it.cont() )
01057     {
01058       if (!FMap->isMarked(*it,mark)) //brin non encore parcouru
01059         {
01060           // On parcours la composante connexe incidente
01061           getIncludingBoxForDarts(*it,ORBIT_0123,min,max);
01062           debutComposante(AFout,min,max);
01063 
01064           CDynamicCoverage0123 covCc(FMap,*it);
01065           while ( covCc.cont() )
01066             {
01067               if (!FMap->isMarked(*covCc,mark)) //brin non encore parcouru
01068                 {
01069                   getIncludingBoxForDarts(*covCc,ORBIT_012,min,max);
01070                   debutComposante(AFout,min,max);
01071 
01072                   // On parcours le volume incident
01073                   CDynamicCoverageVolume covV(FMap,*covCc);
01074                   while ( covV.cont() )
01075                     {
01076                       if (!FMap->isMarked(*covV,mark)) //brin non traité
01077                         {
01078                           getIncludingBoxForDarts(*covV,ORBIT_01,min,max);
01079                           debutComposante(AFout,min,max);
01080 
01081                           treatFilledFace(AFout,*covV,mark,0);
01082 
01083                           AFout<<"-6\n";  //pour fermer la composante xfig
01084                         }  //Fin du parcours d'une region
01085                       ++covV;
01086                     } // Fin du parcours d'un volume
01087                   AFout<<"-6\n";  //pour fermer la composante xfig
01088                 }
01089               ++covCc;
01090             } // Fin du parcours de tout
01091           AFout<<"-6\n";  //pour fermer la composante xfig
01092         }
01093         
01094       if (!FMap->isMarked(*it,mark2))
01095         treatLignel(AFout,*it,mark2);
01096 
01097       if (!FMap->isMarked(*it,mark3))
01098         treatPointel(AFout,*it,mark3);                  
01099 
01100       ++it;
01101     }
01102 
01103   FMap->negateMaskMark(mark);
01104   FMap->freeMark(mark);
01105   FMap->negateMaskMark(mark2);
01106   FMap->freeMark(mark2);
01107   FMap->negateMaskMark(mark3);
01108   FMap->freeMark(mark3);
01109 }
01110 
01111 #undef WEIGHTING
01112 //******************************************************************************