/[ff3d]/ff3d/solver/SurfaceMeshGenerator.cpp
ViewVC logotype

Diff of /ff3d/solver/SurfaceMeshGenerator.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.46 by delpinux, Wed Oct 8 12:37:27 2003 UTC revision 1.47 by dobj, Wed Oct 8 15:49:11 2003 UTC
# Line 278  private: Line 278  private:
278                       const Cell* cell,                       const Cell* cell,
279                       std::vector<Triangle>& triangleListIntersectionNew);                       std::vector<Triangle>& triangleListIntersectionNew);
280    
   void __createCase1(int ncase,  
                      const TriangleCut& K,  
                      const Cell* cell,  
                      std::vector<Triangle>& triangleListIntersectionNew);  
   
   void __createCase2(int ncase,  
                      const TriangleCut& K,  
                      const Cell* cell,  
                      std::vector<Triangle>& triangleListIntersectionNew);  
   
281    void __createLocalListIntersection(const size_t& objectNumber,    void __createLocalListIntersection(const size_t& objectNumber,
282                                       const ObjectToTreat& O2,                                       const ObjectToTreat& O2,
283                                       const Triangle*& currentTriangle,                                       const Triangle*& currentTriangle,
# Line 313  private: Line 303  private:
303                         const Connectivity<Triangle>& connect,                         const Connectivity<Triangle>& connect,
304                         const std::set<const Cell*>& toTreatHexahedra);                         const std::set<const Cell*>& toTreatHexahedra);
305        
   void __createListTriangle(const TriangleCut& K,  
                             const Cell* cell,  
                             std::vector<Triangle>& triangleListIntersectionNew);  
   
306    void __createByEdges(const TriangleCut& K,const Cell* cell,    void __createByEdges(const TriangleCut& K,const Cell* cell,
307                         std::vector<Triangle>& triangleListIntersectionNew);                         std::vector<Triangle>& triangleListIntersectionNew);
308    
# Line 1279  __determinateCase(const int& ncase, Line 1265  __determinateCase(const int& ncase,
1265  }  }
1266    
1267  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
 __createCase1(int ncase,  
               const TriangleCut& K,  
               const Cell* cell,  
               std::vector<Triangle>& triangleListIntersectionNew)  
 {  
     //case 1 points is inside  
     //ncase=number of the point which is inside  
   const Vertex& V0=K(0);  
   const Vertex& V1=K(1);  
   const Vertex& V2=K(2);  
       
   const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection;  
   const std::map< const Vertex* ,const Vertex* >& pointsInterior=K.pointsin;  
   const size_t& numberPointsInterior=pointsInterior.size();  
   const Vertex& A=K(ncase);  
   
   TinyVector<3,int> edgesCut;  
   TinyVector<3,int> vertexNum;  
   
   __determinateCase(ncase,K,edgesCut,vertexNum);  
   
   switch (numberPointsInterior) {  
   case 0: {  
     if(edgesCut[0]==1) {  
       const Vertex& B=__determinateNumber(vertexNum[0],pointsIntersection);  
       if(edgesCut[1]==1) {  
         const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);  
           if(B==C) {  
               //cas ou les 2 points d'intersections sont de meme adresse (donc confondus)  
               //ffout(4)<<"we have a problem createcase1\n";  
               //ffout(4)<<A<<&A<<"\n";  
               //ffout(4)<<B<<&B<<"\n";  
               //ffout(4)<<C<<&C<<"\n";  
           } else {  
               __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
           }  
       } else {  
         ffout(4) <<"pbs 10\n"<<std::flush;  
         ffout(4)<<V0<<"\n";  
         ffout(4)<<V1<<"\n";  
         ffout(4)<<V2<<"\n";  
         ffout(4)<<edgesCut<<"\n";  
       }  
     } else {  
       if(edgesCut[1]==1) {  
         ffout(4)<<"pbs 11\n"<<std::flush;  
         ffout(4)<<V0<<"\n";  
         ffout(4)<<V1<<"\n";  
         ffout(4)<<V2<<"\n";  
         ffout(4)<<edgesCut<<"\n";  
       } else {  
          // if(edgesCut==0) {  
            //  __addTriangle(Triangle(V0,V1,V2,K.reference()),cell,triangleListIntersectionNew);  
           //} else {  
               ffout(4) <<"pbs 111\n";  
               ffout(4)<<edgesCut<<"\n";  
           //}  
       }  
     }  
     break;  
   }  
   default: {  
 #warning is it true? case where only one edge is cut?  
     ffout(4) << numberPointsInterior<<" be careful 1\n"<<std::flush;  
       //case 1 point inside and more than 1 point in the triangle  
      __createGeneral(K, cell, triangleListIntersectionNew);  
   }  
   }  
 }  
   
 void SurfaceMeshGenerator::Internals::  
 __createCase2(int ncase,  
               const TriangleCut& K,  
               const Cell* cell,  
               std::vector<Triangle>& triangleListIntersectionNew)  
 {  
     // case 2 points inside  
   TinyVector<2,int> edgesCut;  
   TinyVector<2,int> vertexNum;  
   const Vertex& V0=K(0);  
   const Vertex& V1=K(1);  
   const Vertex& V2=K(2);  
   
   const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection;  
   const std::map<const Vertex* ,const Vertex*>& pointsInterior=K.pointsin;  
   const TinyVector<3,TinyVector<2,int> >&  edgesCut2=K.edgecut;  
   const size_t& numberPointsInterior=pointsInterior.size();  
   
   size_t ncase0=0,ncase1=1;  
   switch (ncase) {  
   case 0: {  
     edgesCut[0]=edgesCut2[1][0];  
     edgesCut[1]=edgesCut2[2][0];  
     vertexNum[0]=1;  
     vertexNum[1]=2;  
     break;  
   }  
   case 1: {  
     edgesCut[0]=edgesCut2[0][0];  
     edgesCut[1]=edgesCut2[2][0];  
     vertexNum[0]=0;  
     vertexNum[1]=2;  
     ncase0=0;  
     ncase1=2;  
     break;  
   }  
   case 2: {  
     edgesCut[0]=edgesCut2[0][0];  
     edgesCut[1]=edgesCut2[1][0];  
     vertexNum[0]=0;  
     vertexNum[1]=1;  
     ncase0=1;  
     ncase1=2;  
   }  
   }  
   
   const Vertex& A=K(ncase0);  
   const Vertex& B=K(ncase1);  
   
   switch (numberPointsInterior) {  
   case 0: {  
     if(edgesCut[0]==1) {  
       const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);  
       if(edgesCut[1]==1) {  
         const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);  
 //#warning Reference not set.  
           if(D==C) {  
               //si les 2 points d'inter sont confondus  
               if(!(D==V0 or D==V1 or D==V2)) {  
                   //si le point d'inter n'est confondus avec aucun des sommets  
                   //ffout(4)<<"we have a problem\n";  
                   //ffout(4)<<V0<<&V0<<"\n";  
                   //ffout(4)<<V1<<&V1<<"\n";  
                   //ffout(4)<<V2<<&V2<<"\n";  
                   //ffout(4)<<A<<&A<<"\n";  
                   //ffout(4)<<B<<&B<<"\n";  
                   //ffout(4)<<C<<&C<<"\n";  
                   // le triangle est vraisemblablement plat mais il le faut pour la connectivite du maillage  
                   __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
               } else {  
                   //il y a une point d'inter confondu avec un des sommets  
                   //il faut voir si ce n'est pas A ou B et dans ce cas on construit  
                   if(!(C==A or C==B)) {  
                       __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
                   }  
               }  
           } else {  
               __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
               __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);  
           }  
             
       } else {  
          ffout(4) <<"pbs 20\n";  
 //#warning Reference not set.  
         //__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
       }  
     } else {  
       if(edgesCut[1]==1) {  
          ffout(4) <<"pbs 210\n";  
         const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);  
 //#warning Reference not set.  
         //__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
       } else {  
         ffout(4) <<"pbs 21\n"<<std::flush;  
         ffout(4)<<V0<<"\n";  
         ffout(4)<<V1<<"\n";  
         ffout(4)<<V2<<"\n";  
         ffout(4)<<edgesCut2<<"\n";  
       }  
     }  
     break;  
   }  
   case 1: {  
     std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();  
     const Vertex& E=*((*it).second);  
   
     if(edgesCut[0]==1) {  
       const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);  
       if(edgesCut[1]==1) {  
         const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);  
 //#warning Reference not set.  
           __addTriangle(Triangle(A,C,E,K.reference()),cell,triangleListIntersectionNew);  
         __addTriangle(Triangle(A,E,B,K.reference()),cell,triangleListIntersectionNew);  
         __addTriangle(Triangle(B,E,D,K.reference()),cell,triangleListIntersectionNew);  
       } else {  
         __addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew);  
         __addTriangle(Triangle(C,E,B,K.reference()),cell,triangleListIntersectionNew);  
       }  
     } else {  
       if(edgesCut[1]==1) {  
         const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);  
 //#warning Reference not set.  
         __addTriangle(Triangle(D,E,B,K.reference()),cell,triangleListIntersectionNew);  
         __addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew);  
       } else {  
         __addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew);  
       }  
     }  
     break;  
   }  
   default: {  
     //POUR STEPH :  peut generer des tr plats  
     ffout(4) << numberPointsInterior <<"be careful 2\n"<<std::flush;  
     //     ffout(4)<<V0<<"\n";  
     //   ffout(4)<<V1<<"\n";  
     // ffout(4)<<V2<<"\n";  
 //    TinyVector<10,const Vertex*> P,Ptemp;  
 //    size_t i=0;  
 //    for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();  
 //      it!=pointsInterior.end() ; ++it) {  
 //      P[i+1]=(*it).second;  
 //      ++i;  
 //    }  
   
     // CECILE: les deux 'if' qui suivent en sont-ils vraiment ou  
     // veux-tu vérifier simplement que l'assertion est vérifiée ?  
     // Dans ce cas, il serait bien préférable d'utiliser assert()  
   
 //    if(edgesCut[0]==1) {  
 //      const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);  
 //      __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  
 //      P[0]=&C;  
 //      if(edgesCut[1]==1) {  
 //      const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);  
 //      size_t size=numberPointsInterior+1;  
 //      for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) {  
 //        size_t num=1;  
 //        real_t norm=Norm((*P[0])-(*P[1]));  
 //        for(size_t i=2 ; i<size ; ++i) {  
 //          real_t normtemp=Norm((*P[0])-(*P[i]));  
 //          if(normtemp<=norm) {  
 //            norm=normtemp;  
 //            Ptemp[i-1]=P[num];  
 //            num=i;  
 //          } else {  
 //            Ptemp[i-1]=P[i];  
 //          }  
 //        }  
 //#warning Reference not set.  
 //        __addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew);  
 //        Ptemp[0]=P[num];  
 //        P=Ptemp;  
 //        --size;  
 //        // ffout(4)<<"size = "<<size<<"\n";  
 //      }  
 //#warning Reference not set.  
 //      __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);  
 //      __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew);  
 //      //__addTriangle(A,B,D,cell);  
 //      } else {  
 //      ffout(4)<<"une seule arete cut pbs\n";  
 //      }  
 //    } else {  
 //      ffout(4)<<"une seule arete cut pbs2\n";  
 //    }  
   }  
   }  
 }  
   
 void SurfaceMeshGenerator::Internals::  
1268  __createLocalListIntersection(const size_t& objectNumber,  __createLocalListIntersection(const size_t& objectNumber,
1269                                const ObjectToTreat& O2,                                const ObjectToTreat& O2,
1270                                const Triangle*& currentTriangle,                                const Triangle*& currentTriangle,
# Line 1589  __createLocalListIntersection(const size Line 1315  __createLocalListIntersection(const size
1315            const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0];            const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0];
1316            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];
1317            const Triangle T=(*(*jt0));            const Triangle T=(*(*jt0));
           real_t epsilon=1e-6;  
1318            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))
1319               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {
1320              //ffout(4)<<"inter confondu avec arete\n";              //ffout(4)<<"inter confondu avec arete\n";
1321              isDegenerate=1;              isDegenerate=0;
1322            }            }
1323          }          }
1324          if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) {
1325            for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) {            for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) {
1326              const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b];              const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b];
1327                const Triangle T=(*(*jt0));              const Triangle T=(*(*jt0));
1328                real_t epsilon=1e-6;              // si on a le point est confondu avec un sommet on n'a pas besoin du triangle pour la connectivite
1329              if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2))              if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2))
1330                  or b==0) {                  /*or b==0*/) {
1331                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {
1332                  TinyVector<2,const Triangle*> triangles;                  TinyVector<2,const Triangle*> triangles;
1333                  triangles[0]=*jt0;                  triangles[0]=*jt0;
# Line 1969  __putEdgeRef(const Triangle*& Tmesh, Line 1694  __putEdgeRef(const Triangle*& Tmesh,
1694   }   }
1695    
1696  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
 __createListTriangle(const TriangleCut& K,  
                      const Cell* cell,  
                      std::vector<Triangle>& triangleListIntersectionNew)  
 {  
     //create triangles "include" in the triangle K  
   const TinyVector<3,TinyVector<2,int> >&  edgesCut=K.edgecut;  
   const TinyVector<3,size_t>& isIn=K.isInTriangle;  
   const Vertex& V0=K(0);  
   const Vertex& V1=K(1);  
   const Vertex& V2=K(2);  
     
   if(((edgesCut[0][0]+edgesCut[1][0]+edgesCut[2][0]==0 and isIn[0]+isIn[1]+isIn[2]==3) /*or isIn[0]+isIn[1]+isIn[2]==3*/)) {  
 //#warning Reference not set.  
     __addTriangle(Triangle(V0,V1,V2,K.reference()),cell,triangleListIntersectionNew);  
   } else {  
     if(isIn[0]+isIn[1]+isIn[2]==1) {  
       if(isIn[0]==1) {  
         __createCase1(0,K,cell,triangleListIntersectionNew);  
       }  
       if(isIn[1]==1) {  
         __createCase1(1,K,cell,triangleListIntersectionNew);  
       }  
       if(isIn[2]==1) {  
         __createCase1(2,K,cell,triangleListIntersectionNew);  
       }  
     } else {  
       if(isIn[0]+isIn[1]+isIn[2]==2) {  
         if(isIn[0]+isIn[1]==2) {  
           __createCase2(0,K,cell,triangleListIntersectionNew);  
         }  
         if(isIn[0]+isIn[2]==2) {  
           __createCase2(1,K,cell,triangleListIntersectionNew);  
         }  
         if(isIn[1]+isIn[2]==2) {  
           __createCase2(2,K,cell,triangleListIntersectionNew);  
         }  
       }  
     }  
   }  
 }  
   
 void SurfaceMeshGenerator::Internals::  
1697  __createGeneral(const TriangleCut& K,const Cell* cell,  __createGeneral(const TriangleCut& K,const Cell* cell,
1698                  std::vector<Triangle>& triangleListIntersectionNew)                  std::vector<Triangle>& triangleListIntersectionNew)
1699  {  {
1700  //Initialisation pour l'instant on suppose un point in  // pour l'instant on suppose edge cut une seule fois
1701      size_t iCut=0, iInter=0, stop=0,in=0;      size_t iCut=0, iInter=0, stop=0,in=0,in1=0;
1702      size_t nbInter=triangleWithVertex.size();      size_t nbInter=triangleWithVertex.size();
1703      size_t nbCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0];      size_t nbCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0];
1704      TinyVector<2,const Vertex*> P;      TinyVector<2,const Vertex*> P;
1705      TinyVector<2,const Triangle*> T;      TinyVector<2,const Triangle*> T;
1706      TinyVector<3,size_t> place;      TinyVector<3,size_t> place;
1707      if(K.isInTriangle[1]==1) {      size_t numberIn=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2];
1708          in=1;      switch (numberIn) {
1709          place[0]=2;        case 1: {
1710          place[1]=0;            if(K.isInTriangle[1]==1) {
1711          place[2]=1;                in=1;
1712      } else if(K.isInTriangle[2]==1) {                place[0]=2;
1713          in=2;                place[1]=0;
1714          place[0]=1;                place[2]=1;
1715          place[1]=2;            } else if(K.isInTriangle[2]==1) {
1716          place[2]=0;                in=2;
1717      } else {                place[0]=1;
1718          place[0]=0;                place[1]=2;
1719          place[1]=1;                place[2]=0;
1720          place[2]=2;            } else {
1721                  place[0]=0;
1722                  place[1]=1;
1723                  place[2]=2;
1724              }
1725              break;
1726          }
1727          case 2: {
1728              if(K.isInTriangle[1]==1 and K.isInTriangle[0]==1) {
1729                  in=1;
1730                  in1=0;
1731                  place[0]=1;
1732                  place[1]=2;
1733                  place[2]=0;
1734              } else if(K.isInTriangle[2]==1 and K.isInTriangle[1]==1) {
1735                  in=2;
1736                  in1=1;
1737                  place[0]=0;
1738                  place[1]=1;
1739                  place[2]=2;
1740              } else {
1741                  in=0;
1742                  in1=2;
1743                  place[0]=2;
1744                  place[1]=0;
1745                  place[2]=1;
1746              }
1747              break;
1748          }  
1749      }      }
1750      const Vertex* A=&K(in);      const Vertex* A=&K(in);
1751      P[0]=K.pointsIntersection[place[0]][0];      P[0]=K.pointsIntersection[place[0]][0];
# Line 2045  __createGeneral(const TriangleCut& K,con Line 1756  __createGeneral(const TriangleCut& K,con
1756          stop=1;          stop=1;
1757          ffout(4)<<"pbs 0 existe pas\n";          ffout(4)<<"pbs 0 existe pas\n";
1758      }      }
1759        if(numberIn==2 and stop==0) {
1760            __addTriangle(Triangle(K(in1),*A,*P[0],K.reference()),cell,triangleListIntersectionNew);
1761        }
1762      //iInter=1;      //iInter=1;
1763      while(iInter<nbInter and stop==0) {      while(iInter<nbInter and stop==0) {
1764          ffout(4)<<"createGeneral "<<iInter<<" "<<nbInter<<"\n";          //ffout(4)<<"createGeneral "<<iInter<<" "<<nbInter<<"\n";
1765          //on cherche le voisin de Pi          //on cherche le voisin de Pi
1766          if(triangleWithVertex.find(T[0])!=triangleWithVertex.end()) {          if(triangleWithVertex.find(T[0])!=triangleWithVertex.end()) {
1767              TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[0])).second;              TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[0])).second;
# Line 2056  __createGeneral(const TriangleCut& K,con Line 1770  __createGeneral(const TriangleCut& K,con
1770                      //on est a priori sur une arete                      //on est a priori sur une arete
1771                      if(iCut<nbCut) {                      if(iCut<nbCut) {
1772                          #warning CAS edge cut twice                          #warning CAS edge cut twice
1773                            //ffout(4)<<"cas 1\n";
1774                          P[1]=K.pointsIntersection[place[iCut]][0];                          P[1]=K.pointsIntersection[place[iCut]][0];
                         if(nbInter==2) {  
                             ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n";  
                         }  
1775                          __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);                          __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1776                          P[0]=P[1];                          P[0]=P[1];
1777                          ++iInter;                          ++iInter;
# Line 2069  __createGeneral(const TriangleCut& K,con Line 1781  __createGeneral(const TriangleCut& K,con
1781                          ffout(4)<<"on s'arrete en plein milieu\n";                          ffout(4)<<"on s'arrete en plein milieu\n";
1782                      }                      }
1783                  } else {                  } else {
1784                        //ffout(4)<<"cas 2\n";
1785                      P[1]=VV[1];                      P[1]=VV[1];
                     if(nbInter==2) {  
                         ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n";  
                     }  
1786                      __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);                      __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1787                      P[0]=P[1];                      P[0]=P[1];
1788                      ++iInter;                      ++iInter;
1789                  }                  }
1790              } else {              } else {
1791                    //ffout(4)<<"cas 3\n";
1792                  P[1]=VV[0];                  P[1]=VV[0];
                 if(nbInter==2) {  
                     ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n";  
                 }  
1793                  __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);                  __addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1794                  P[0]=P[1];                  P[0]=P[1];
1795                  ++iInter;                  ++iInter;
# Line 2101  __createGeneral(const TriangleCut& K,con Line 1809  __createGeneral(const TriangleCut& K,con
1809              }              }
1810              if(T2[0]==T[0]) {              if(T2[0]==T[0]) {
1811                  if(T2[1]==T[0]) {                  if(T2[1]==T[0]) {
1812                      stop=1;                      ++iCut;
1813                      ffout(4)<<"pbs triangle\n";                      if(iCut<nbCut) {
1814                            #warning CAS edge cut twice
1815                            ffout(4)<<iCut<<" cas new\n";
1816                            if(P[0]==K.pointsIntersection[place[iCut]][0]) {
1817                                ffout(4)<<"j'ai le point1\n";
1818                                --iCut;
1819                            }
1820                            if(P[0]==K.pointsIntersection[place[1]][0]) {
1821                                ffout(4)<<"j'ai le point2\n";
1822                                --iCut;
1823                            }
1824                            if(P[0]==K.pointsIntersection[place[0]][0]) {
1825                                ffout(4)<<"j'ai le point3\n";
1826                                --iCut;
1827                            }
1828                            
1829                            
1830                            //P[1]=K.pointsIntersection[place[iCut]][0];
1831                            //__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1832                            //P[0]=P[1];
1833                            //++iInter;
1834                            //++iCut;
1835                        } else {
1836                            stop=1;
1837                            ffout(4)<<"nbCut icut "<<iCut<<" "<<nbCut<<"\n";
1838                            ffout(4)<<"pbs triangle\n";
1839                        }
1840                        
1841                  } else {                  } else {
1842                      T[0]=T2[1];                      T[0]=T2[1];
1843                  }                  }
# Line 2556  __createTrianglesIntersection(const size Line 2291  __createTrianglesIntersection(const size
2291          vertexInTriangles.clear();          vertexInTriangles.clear();
2292                    
2293          __createLocalListIntersection(objectNumber,O2,T,K,*i);          __createLocalListIntersection(objectNumber,O2,T,K,*i);
2294            std::map< const Vertex* ,const Vertex*> pointsin=K.pointsin;
2295            size_t numberP=pointsin.size();
2296                    
2297          const Vertex* P0=(*listOfVertexMesh.find(&K(0))).second;          const Vertex* P0=(*listOfVertexMesh.find(&K(0))).second;
2298          const Vertex* P1=(*listOfVertexMesh.find(&K(1))).second;          const Vertex* P1=(*listOfVertexMesh.find(&K(1))).second;
# Line 2597  __createTrianglesIntersection(const size Line 2334  __createTrianglesIntersection(const size
2334            } else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) {            } else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) {
2335              if(vertexInTriangles.size()==3) {              if(vertexInTriangles.size()==3) {
2336                //there are 3 points intersection so we create a triangle                //there are 3 points intersection so we create a triangle
2337                  __3pointsintersection(K,*i,triangleListIntersectionNew);                  //__3pointsintersection(K,*i,triangleListIntersectionNew);
2338              } else {              } else {
2339                  size_t numberEdgesCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0];                  size_t numberEdgesCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0];
2340                if(vertexInTriangles.size()>3 and numberEdgesCut==1){                if(vertexInTriangles.size()>3 and numberEdgesCut==1){
2341                  //one edge cut but twice                  //one edge cut but twice
2342                  ffout(4)<<"createNotIn\n";                  ffout(4)<<"createNotIn\n";
2343                  //POUR STEPH : createNotIn peut generer des tr plats                  //POUR STEPH : createNotIn peut generer des tr plats
2344                  __createNotIn(K,*i, triangleListIntersectionNew);                  //__createNotIn(K,*i, triangleListIntersectionNew);
2345                } else {                } else {
2346                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {
2347                    //two edge cut but twice                    //two edge cut but twice
# Line 2699  __createTrianglesIntersection(const size Line 2436  __createTrianglesIntersection(const size
2436                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]
2437                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {
2438                   ffout(4)<<"---------------- 3 edge cut \n";                   ffout(4)<<"---------------- 3 edge cut \n";
2439                   __createByEdges(K,*i,triangleListIntersectionNew);                   //__createGeneral(K,*i,triangleListIntersectionNew);
2440              } else {              } else {
2441                  __createListTriangle(K,*i,triangleListIntersectionNew);                  if(numberP<=2) {
2442                     __createGeneral(K, *i, triangleListIntersectionNew);
2443                    } else {
2444                        ffout(4)<<"numberP "<<numberP<<"\n";
2445                    }
2446              }              }
2447            } else {            } else {
2448                __createListTriangle(K,*i,triangleListIntersectionNew);                if(numberP<=2) {
2449                      __createGeneral(K, *i, triangleListIntersectionNew);
2450                  } else {
2451                      ffout(4)<<"numberP "<<numberP<<"\n";
2452                  }
2453            }            }
2454            break;            break;
2455          }          }
# Line 2712  __createTrianglesIntersection(const size Line 2457  __createTrianglesIntersection(const size
2457              if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) {              if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) {
2458                  ffout(4)<<"case 2 pas traite \n";                  ffout(4)<<"case 2 pas traite \n";
2459              } else {              } else {
2460               __createListTriangle(K,*i,triangleListIntersectionNew);                  if(numberP<=2) {
2461                        __createGeneral(K, *i, triangleListIntersectionNew);
2462                    } else {
2463                        ffout(4)<<"numberP "<<numberP<<"\n";
2464                    }
2465              }              }
2466            break;            break;
2467          }          }
# Line 3488  generateSurfacicMesh(const Domain& omega Line 3237  generateSurfacicMesh(const Domain& omega
3237    (*__internals).__constructionFinalMesh((*objectStack.top()),    (*__internals).__constructionFinalMesh((*objectStack.top()),
3238                                           s_mesh);                                           s_mesh);
3239    
3240    #warning _________________________________A ENLEVER_________  /*  #warning _________________________________A ENLEVER_________
3241    Connectivity<Triangle> connect(s_mesh.numberOfCells());    Connectivity<Triangle> connect(s_mesh.numberOfCells());
3242    ConnectivityBuilder<SurfaceMeshOfTriangles> C(s_mesh,connect);    ConnectivityBuilder<SurfaceMeshOfTriangles> C(s_mesh,connect);
3243    size_t compt=0;    size_t compt=0;
# Line 3502  generateSurfacicMesh(const Domain& omega Line 3251  generateSurfacicMesh(const Domain& omega
3251            }            }
3252        }        }
3253    }    }
3254    ffout(4)<<"****************************il manque "<<compt<<" sommets\n";    ffout(4)<<"****************************il manque "<<compt<<" sommets\n";*/
3255    /////////////////////////////////////////////////////////////////////////////    /////////////////////////////////////////////////////////////////////////////
3256    
3257    int n0=0, n1=0;    int n0=0, n1=0;

Legend:
Removed from v.1.46  
changed lines
  Added in v.1.47

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26