/[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.37 by dobj, Mon Sep 15 16:13:46 2003 UTC revision 1.38 by dobj, Tue Sep 16 17:26:18 2003 UTC
# Line 1017  __DeterminatePoint(const size_t& ncase, Line 1017  __DeterminatePoint(const size_t& ncase,
1017      real_t inV12=Norm(V12^V1P);      real_t inV12=Norm(V12^V1P);
1018      real_t inV02=Norm(V02^V2P);      real_t inV02=Norm(V02^V2P);
1019    
1020      if(/*norm2>epsilon and norm3>epsilon and*/ std::abs((norm2+norm3)-norm1) < epsilon ) {      if(/*norm2>epsilon and norm3>epsilon and */std::abs((norm2+norm3)-norm1) < epsilon ) {
1021        if(ncase<3) {        if(ncase<3) {
1022          __InTriangle(P,V,num);          __InTriangle(P,V,num);
1023          if(num==3) {          if(num==3) {
1024  //        if(!(norm2>epsilon)) {            if(!(norm2>epsilon)) {
1025  //          Pinter.addPoint(Vo0);              Pinter.addPoint(Vo0);
1026  //        } else            } else
1027  //          if(!(norm3>epsilon)) {              if(!(norm3>epsilon)) {
1028  //            Pinter.addPoint(Vo1);                Pinter.addPoint(Vo1);
1029  //          } else              } else
1030                if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end()                if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end()
1031                   and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) {                   and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) {
1032                  listVertexIntersectionNew[pV][0]=new Vertex (P);                  listVertexIntersectionNew[pV][0]=new Vertex (P);
# Line 1066  __DeterminatePoint(const size_t& ncase, Line 1066  __DeterminatePoint(const size_t& ncase,
1066              //ffout(4)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n";              //ffout(4)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n";
1067              //listVertexIntersectionNew.push_back(new Vertex (P));              //listVertexIntersectionNew.push_back(new Vertex (P));
1068              PIntersection PIn;              PIntersection PIn;
1069  //          if(!(norm2>epsilon)) {              if(!(norm2>epsilon)) {
1070  //            Pinter.addPoint(Vo0);                Pinter.addPoint(Vo0);
1071  //          } else {              } else {
1072  //            if(!(norm3>epsilon)) {                if(!(norm3>epsilon)) {
1073  //              Pinter.addPoint(Vo1);                  Pinter.addPoint(Vo1);
1074  //            } else                } else
1075                  {                  {
1076                  if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end()                  if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end()
1077                     and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) {                     and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) {
# Line 1108  __DeterminatePoint(const size_t& ncase, Line 1108  __DeterminatePoint(const size_t& ncase,
1108                    }                    }
1109                  }                  }
1110                }                }
1111                //            }                      }
1112              // Pinter.addPoint(listVertexIntersectionNew[listVertexIntersectionNew.size()-1]);              // Pinter.addPoint(listVertexIntersectionNew[listVertexIntersectionNew.size()-1]);
1113            }            }
1114          }          }
# Line 1216  __createPointIntersection(std::list<Tria Line 1216  __createPointIntersection(std::list<Tria
1216        real_t norm1=Norm(P-Vo1);        real_t norm1=Norm(P-Vo1);
1217        real_t norm2=Norm(P-Vo2);        real_t norm2=Norm(P-Vo2);
1218        //for filter points        //for filter points
1219        //real_t eps=1e-10;        real_t eps=1e-6;
1220        if(/*norm0>eps and norm1>eps and*/ std::abs((norm0+norm1)-Vo01)<epsilon) {        if(/*norm0>eps and norm1>eps and */std::abs((norm0+norm1)-Vo01)<epsilon) {
1221          cutTr2[0]=i+1;          cutTr2[0]=i+1;
1222        }        }
1223        if(/*norm0>eps and norm2>eps and */std::abs((norm0+norm2)-Vo02)<epsilon) {        if(/*norm0>eps and norm2>eps and */std::abs((norm0+norm2)-Vo02)<epsilon) {
# Line 1252  __addTriangle(const Triangle& t, Line 1252  __addTriangle(const Triangle& t,
1252    if(!__isDegenerate(T)) {    if(!__isDegenerate(T)) {
1253      triangleListIntersectionNew.push_back(T);      triangleListIntersectionNew.push_back(T);
1254    } else {    } else {
1255      fferr(4) << "\t\tTriangle dégénéré :"      fferr(3) << "\t\tTriangle dégénéré :"
1256               << &T(0) << ':' << &T(1) << ':' << &T(2) << '\n';               << &T(0) << ':' << &T(1) << ':' << &T(2) << '\n';
1257      triangleListIntersectionNew.push_back(T);        fferr(3)
1258              << T(0) << ':' << T(1) << ':' << T(2) << '\n';
1259       // triangleListIntersectionNew.push_back(T);
1260    }    }
1261  }  }
1262    
# Line 1447  __createCase2(int ncase, Line 1449  __createCase2(int ncase,
1449        if(edgesCut[1]==1) {        if(edgesCut[1]==1) {
1450          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1451  //#warning Reference not set.  //#warning Reference not set.
1452          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);            if(D==C) {
1453          __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);                if(!(D==K(0) or D==K(1) or D==K(2))) {
1454                      if(Norm(D-K(0))<1e-6 or Norm(D-K(1))<1e-6 or Norm(D-K(2))<1e-6) {
1455                          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1456                      } else {
1457                          ffout(4)<<"we have a problem\n";
1458                          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1459                          __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);
1460                      }
1461                  } else {
1462                      __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1463                  }
1464              } else {
1465                  __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1466                  __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);
1467              }
1468        } else {        } else {
1469          // ffout(4) <<"pbs 20\n";           ffout(4) <<"pbs 20\n";
1470  //#warning Reference not set.  //#warning Reference not set.
1471          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1472        }        }
1473      } else {      } else {
1474        if(edgesCut[1]==1) {        if(edgesCut[1]==1) {
1475          // ffout(4) <<"pbs 210\n";           ffout(4) <<"pbs 210\n";
1476          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);
1477  //#warning Reference not set.  //#warning Reference not set.
1478          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
# Line 1504  __createCase2(int ncase, Line 1520  __createCase2(int ncase,
1520      //     ffout(4)<<V0<<"\n";      //     ffout(4)<<V0<<"\n";
1521      //   ffout(4)<<V1<<"\n";      //   ffout(4)<<V1<<"\n";
1522      // ffout(4)<<V2<<"\n";      // ffout(4)<<V2<<"\n";
1523      TinyVector<10,const Vertex*> P,Ptemp;  //    TinyVector<10,const Vertex*> P,Ptemp;
1524      size_t i=0;  //    size_t i=0;
1525      for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();  //    for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();
1526          it!=pointsInterior.end() ; ++it) {  //      it!=pointsInterior.end() ; ++it) {
1527        P[i+1]=(*it).second;  //      P[i+1]=(*it).second;
1528        ++i;  //      ++i;
1529      }  //    }
1530    
1531      // CECILE: les deux 'if' qui suivent en sont-ils vraiment ou      // CECILE: les deux 'if' qui suivent en sont-ils vraiment ou
1532      // veux-tu vérifier simplement que l'assertion est vérifiée ?      // veux-tu vérifier simplement que l'assertion est vérifiée ?
1533      // Dans ce cas, il serait bien préférable d'utiliser assert()      // Dans ce cas, il serait bien préférable d'utiliser assert()
1534    
1535      if(edgesCut[0]==1) {  //    if(edgesCut[0]==1) {
1536        const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);  //      const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);
1537        __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);  //      __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1538        P[0]=&C;  //      P[0]=&C;
1539        if(edgesCut[1]==1) {  //      if(edgesCut[1]==1) {
1540          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);  //      const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1541          size_t size=numberPointsInterior+1;  //      size_t size=numberPointsInterior+1;
1542          for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) {  //      for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) {
1543            size_t num=1;  //        size_t num=1;
1544            real_t norm=Norm((*P[0])-(*P[1]));  //        real_t norm=Norm((*P[0])-(*P[1]));
1545            for(size_t i=2 ; i<size ; ++i) {  //        for(size_t i=2 ; i<size ; ++i) {
1546              real_t normtemp=Norm((*P[0])-(*P[i]));  //          real_t normtemp=Norm((*P[0])-(*P[i]));
1547              if(normtemp<=norm) {  //          if(normtemp<=norm) {
1548                norm=normtemp;  //            norm=normtemp;
1549                Ptemp[i-1]=P[num];  //            Ptemp[i-1]=P[num];
1550                num=i;  //            num=i;
1551              } else {  //          } else {
1552                Ptemp[i-1]=P[i];  //            Ptemp[i-1]=P[i];
1553              }  //          }
1554            }  //        }
1555  //#warning Reference not set.  //#warning Reference not set.
1556            __addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew);  //        __addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew);
1557            Ptemp[0]=P[num];  //        Ptemp[0]=P[num];
1558            P=Ptemp;  //        P=Ptemp;
1559            --size;  //        --size;
1560            // ffout(4)<<"size = "<<size<<"\n";  //        // ffout(4)<<"size = "<<size<<"\n";
1561          }  //      }
1562  //#warning Reference not set.  //#warning Reference not set.
1563          __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);  //      __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1564          __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew);  //      __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew);
1565          //__addTriangle(A,B,D,cell);  //      //__addTriangle(A,B,D,cell);
1566        } else {  //      } else {
1567          ffout(4)<<"une seule arete cut pbs\n";  //      ffout(4)<<"une seule arete cut pbs\n";
1568        }  //      }
1569      } else {  //    } else {
1570        ffout(4)<<"une seule arete cut pbs2\n";  //      ffout(4)<<"une seule arete cut pbs2\n";
1571      }  //    }
1572    }    }
1573    }    }
1574  }  }
# Line 1607  __createLocalListIntersection(const size Line 1623  __createLocalListIntersection(const size
1623          if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) {
1624            const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0];            const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0];
1625            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];
1626            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))            const Triangle T=(*(*jt0));
1627               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {            real_t epsilon=1e-6;
1628              //if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))
1629                // and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {
1630              if(Norm((*V0)-(*V1)) <epsilon and (Norm((*V0)-T(0))<epsilon
1631          or Norm((*V0)-T(1))<epsilon
1632          or Norm((*V0)-T(2))<epsilon)){
1633              //ffout(4)<<"inter confondu avec arete\n";              //ffout(4)<<"inter confondu avec arete\n";
1634              isDegenerate=1;              isDegenerate=1;
1635            }            }
# Line 1616  __createLocalListIntersection(const size Line 1637  __createLocalListIntersection(const size
1637          if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) {
1638            for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) {            for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) {
1639              const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b];              const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b];
1640              if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) or b==0) {                const Triangle T=(*(*jt0));
1641                  real_t epsilon=1e-6;
1642                if(/*!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2))*/
1643                    (Norm((*V)-T(0))<epsilon
1644                    or Norm((*V)-T(1))<epsilon
1645                    or Norm((*V)-T(2))<epsilon)
1646                    or b==0) {
1647                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {
1648                  TinyVector<2,const Triangle*> triangles;                  TinyVector<2,const Triangle*> triangles;
1649                  triangles[0]=*jt0;                  triangles[0]=*jt0;
# Line 1656  __createLocalListIntersection(const size Line 1683  __createLocalListIntersection(const size
1683            numberPointsInterior+=1;            numberPointsInterior+=1;
1684            size_t r=0;            size_t r=0;
1685            size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2];            size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2];
1686            if(sum>3) {            if(sum>5) {
1687              ffout(4)<<"sum "<<sum<<"\n"<<std::flush;              ffout(4)<<"sum "<<sum<<"\n"<<std::flush;
1688            }            }
1689    
# Line 1688  __createLocalListIntersection(const size Line 1715  __createLocalListIntersection(const size
1715              ffout(4) << K(1) << "\n";              ffout(4) << K(1) << "\n";
1716              ffout(4) << K(2) << "\n";              ffout(4) << K(2) << "\n";
1717              ffout(4) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n";              ffout(4) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n";
1718                ffout(4) << edgesCut[0] << " " << edgesCut[1] << " " << edgesCut[2] << "\n";
1719                edgesCut[0]=cutTriangle[0];
1720                edgesCut[1]=cutTriangle[1];
1721                edgesCut[2]=cutTriangle[2];
1722                
1723            }            }
1724            }            }
1725            if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r])            if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r])
1726               ==pointsInterior.end()) {               ==pointsInterior.end() and sum<=5) {
1727              pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle][r])]              pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle][r])]
1728                =(pairTriangleToIntersectionPoints[pairTriangle][r]);                =(pairTriangleToIntersectionPoints[pairTriangle][r]);
1729            }            }
# Line 1777  __putRefByFront(const size_t numobject, Line 1809  __putRefByFront(const size_t numobject,
1809      const Triangle* T=&(surfmesh.cell(i));      const Triangle* T=&(surfmesh.cell(i));
1810      const Cell* cell=&((*T).mother());      const Cell* cell=&((*T).mother());
1811      if(toTreatHexahedra.find(cell)!=toTreatHexahedra.end()      if(toTreatHexahedra.find(cell)!=toTreatHexahedra.end()
1812         /*and ((*edgesRefVertex[numobject])[&(*T)(0)]!=0        /* and ((*edgesRefVertex[numobject])[&(*T)(0)]!=0
1813        or (*edgesRefVertex[numobject])[&(*T)(1)]!=0        or (*edgesRefVertex[numobject])[&(*T)(1)]!=0
1814        or (*edgesRefVertex[numobject])[&(*T)(2)]!=0)*/) {        or (*edgesRefVertex[numobject])[&(*T)(2)]!=0)*/) {
1815        front.push_front(T);        front.push_front(T);
# Line 1851  __putRefByFront(const size_t numobject, Line 1883  __putRefByFront(const size_t numobject,
1883              TinyVector<2,int> edge0=Kneigh.edgecut[0];              TinyVector<2,int> edge0=Kneigh.edgecut[0];
1884              TinyVector<2,int> edge1=Kneigh.edgecut[1];              TinyVector<2,int> edge1=Kneigh.edgecut[1];
1885              TinyVector<2,int> edge2=Kneigh.edgecut[2];              TinyVector<2,int> edge2=Kneigh.edgecut[2];
             if(edge0+edge1+edge2==0 and ref0+ref1+ref2!=0 and ref0+ref1+ref2!=6) {  
                 ref0=2;  
                 ref1=2;  
                 ref2=2;  
                 test=1;  
             } else {  
1886              if(ref0+ref1==2 and edge0==0) {              if(ref0+ref1==2 and edge0==0) {
1887                test=1;                test=1;
1888                ref0=2;                ref0=2;
# Line 1878  __putRefByFront(const size_t numobject, Line 1904  __putRefByFront(const size_t numobject,
1904              } else if(edge2[0]==1 and ref2+ref1!=2 and ref0+ref1+ref2!=0){              } else if(edge2[0]==1 and ref2+ref1!=2 and ref0+ref1+ref2!=0){
1905                  //test=1;                  //test=1;
1906              }              }
1907              }              
1908              if(test==1/*ref0+ref1+ref2==6 */or edge0[0]+edge1[0]+edge2[0]==1) {              if(test==1/*ref0+ref1+ref2==6 *//*or edge0[0]+edge1[0]+edge2[0]==1*/) {
1909                front.push_front(triangle);                front.push_front(triangle);
1910              }              }
1911              //ffout(0)<<ref0<<" "<<ref1<<" "<<ref2<<"\n";              //ffout(0)<<ref0<<" "<<ref1<<" "<<ref2<<"\n";
# Line 2331  __createTrianglesIntersection(const size Line 2357  __createTrianglesIntersection(const size
2357    size_t objectNumber=0;    size_t objectNumber=0;
2358    if(numobject==0)    if(numobject==0)
2359      objectNumber=1;      objectNumber=1;
2360     // (*edgesRefVertex[numobject]).clear();
2361    MapCellTriangle hexaToTriangle0=*(O1.hexalist);    MapCellTriangle hexaToTriangle0=*(O1.hexalist);
2362    
2363      
2364    std::set<const Cell*> hexaList1;    std::set<const Cell*> hexaList1;
2365    std::set<const Cell*> hexaListIn;    std::set<const Cell*> hexaListIn;
2366    
# Line 2343  __createTrianglesIntersection(const size Line 2371  __createTrianglesIntersection(const size
2371    std::set_difference (hexaList1.begin(), hexaList1.end(),    std::set_difference (hexaList1.begin(), hexaList1.end(),
2372                         toTreatHexahedra.begin(), toTreatHexahedra.end(),                         toTreatHexahedra.begin(), toTreatHexahedra.end(),
2373                         inserter(hexaListIn, hexaListIn.begin()));                         inserter(hexaListIn, hexaListIn.begin()));
     
   for (std::set<const Cell*>::iterator icell = hexaListIn.begin(); icell != hexaListIn.end(); ++icell) {  
     Cell& C = const_cast<Cell&>(*(*icell));  
     for (size_t i=0; i<C.numberOfVertices(); ++i) {  
       C(i).reference() = ((*O1.shape()).inside(C(i))?1:0)  
         + ((*O2.shape()).inside(C(i))?1:0);  
     }  
   
     size_t ref;  
     if (booleanTest::compute(C)) {  
       ref=2;  
     } else {  
       ref=0;  
     }  
2374    
2375      ffout(4)<<"taille hexalistIn "<<hexaListIn.size()<<"\n";
2376      for (std::set<const Cell*>::iterator icell = hexaListIn.begin(); icell != hexaListIn.end(); ++icell) {
2377        
2378      MapCellTriangle::iterator it0=hexaToTriangle0.find(*icell);      MapCellTriangle::iterator it0=hexaToTriangle0.find(*icell);
2379            
2380      if(it0!=hexaToTriangle0.end()) {      if(it0!=hexaToTriangle0.end()) {
2381        std::list<Triangle*> listTriangle0=(*it0).second;          //ffout(4)<<"ici\n";
2382            Cell& C = const_cast<Cell&>(*(*icell));
2383            for (size_t i=0; i<C.numberOfVertices(); ++i) {
2384                C(i).reference() = ((*O1.shape()).inside(C(i))?1:0)
2385                + ((*O2.shape()).inside(C(i))?1:0);
2386            }
2387    
2388            size_t ref;
2389            if (booleanTest::compute(C)) {
2390                ref=2;
2391            } else {
2392                ref=0;
2393            }
2394            
2395          std::list<Triangle*> listTriangle0=(*it0).second;
2396            ffout(4)<<listTriangle0.size()<<"\n";
2397        for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ;        for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ;
2398            jt0!=listTriangle0.end() ; ++jt0) {            jt0!=listTriangle0.end() ; ++jt0) {
2399    
2400          Triangle& T = (*(*jt0));          Triangle& T = (*(*jt0));
2401          for (size_t n=0; n<3; ++n) {          for (size_t n=0; n<3; ++n) {
2402                // if(ref==2)
2403               // ffout(4)<<"ref ="<<ref<<"\n";
2404            (*edgesRefVertex[numobject])[&T(n)]=ref;            (*edgesRefVertex[numobject])[&T(n)]=ref;
2405              //put ref 2 for points of surfmesh              //put ref 2 for points of surfmesh
2406              const Vertex* P0=(*listOfVertexMesh.find(&T(n))).second;              const Vertex* P0=(*listOfVertexMesh.find(&T(n))).second;
# Line 2427  __createTrianglesIntersection(const size Line 2460  __createTrianglesIntersection(const size
2460    
2461              ffout(4)<<"cas pbssssss\n";              ffout(4)<<"cas pbssssss\n";
2462          }          }
2463                    if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]>=6) {
2464                ffout(4)<<"on veut rien faire car triangle plat\n";
2465                ffout(4)<< K.isInTriangle[0]<<" "<< K.isInTriangle[1]<<" "<< K.isInTriangle[2]<<"\n";
2466                K.isInTriangle[0]=1;
2467                 K.isInTriangle[1]=1;
2468                  K.isInTriangle[2]=1;
2469                
2470            }
2471  ///////////////////////creation des triangles//////////////////////////////  ///////////////////////creation des triangles//////////////////////////////
2472          size_t numberVertexInDomain=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2];          size_t numberVertexInDomain=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2];
2473          switch (numberVertexInDomain) {          switch (numberVertexInDomain) {
# Line 2446  __createTrianglesIntersection(const size Line 2486  __createTrianglesIntersection(const size
2486                  //one edge cut but twice                  //one edge cut but twice
2487                  ffout(4)<<"createNotIn\n";                  ffout(4)<<"createNotIn\n";
2488                  //POUR STEPH : createNotIn peut generer des tr plats                  //POUR STEPH : createNotIn peut generer des tr plats
2489                  __createNotIn(K,*i, triangleListIntersectionNew);                  //__createNotIn(K,*i, triangleListIntersectionNew);
2490                } else {                } else {
2491                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {
2492                    //two edge cut but twice                    //two edge cut but twice
2493                    ffout(4)<<"createNotIn2\n";                    ffout(4)<<"createNotIn2\n";
2494                    __createNotIn2(K,*i, triangleListIntersectionNew);                    //__createNotIn2(K,*i, triangleListIntersectionNew);
2495                  } else {                  } else {
2496                    if(K.edgecut[0]!=0) {                    if(K.edgecut[0]!=0) {
2497                      if(K.pointsIntersection[0][0]==&V0                      if(K.pointsIntersection[0][0]==&V0
# Line 2484  __createTrianglesIntersection(const size Line 2524  __createTrianglesIntersection(const size
2524                            if(vertexInTriangles.size()>3 and                            if(vertexInTriangles.size()>3 and
2525                               K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==1) {                               K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==1) {
2526                              ffout(4)<<"case\n";                              ffout(4)<<"case\n";
2527                              __createNotIn(K,*i,triangleListIntersectionNew);                              //__createNotIn(K,*i,triangleListIntersectionNew);
2528                            }                            }
2529                          }                          }
2530                        } else {                        } else {
# Line 2541  __createTrianglesIntersection(const size Line 2581  __createTrianglesIntersection(const size
2581                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]
2582                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {
2583                   ffout(4)<<"---------------- 3 edge cut \n";                   ffout(4)<<"---------------- 3 edge cut \n";
2584                  __createByEdges(K,*i,triangleListIntersectionNew);                   //__createByEdges(K,*i,triangleListIntersectionNew);
2585              } else {              } else {
2586                  __createListTriangle(K,*i,triangleListIntersectionNew);                  __createListTriangle(K,*i,triangleListIntersectionNew);
2587              }              }
# Line 2551  __createTrianglesIntersection(const size Line 2591  __createTrianglesIntersection(const size
2591            break;            break;
2592          }          }
2593          case 2: {          case 2: {
2594                if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) {
2595                    ffout(4)<<"case 2 pas traite \n";
2596                } else {
2597               __createListTriangle(K,*i,triangleListIntersectionNew);               __createListTriangle(K,*i,triangleListIntersectionNew);
2598                }
2599            break;            break;
2600          }          }
2601          case 3: {          case 3: {
2602              if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==0) {              if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==0) {
2603                __addTriangle(*T,*i,triangleListIntersectionNew);                __addTriangle(*T,*i,triangleListIntersectionNew);
2604              } else {              } else {
2605                  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) {
# Line 3301  generateSurfacicMesh(const Domain& omega Line 3345  generateSurfacicMesh(const Domain& omega
3345    
3346    const Object& object = omega.object();    const Object& object = omega.object();
3347    const Scene& scene = omega.scene();    const Scene& scene = omega.scene();
3348      //(*__internals).edgesRefVertex.resize(scene.nbObjects());
3349      (*__internals).edgesRefVertex.resize(2);
3350    
3351    (*__internals).edgesRefVertex.resize(scene.nbObjects());    for(size_t no=0 ; no<2/*scene.nbObjects()*/ ; ++no) {
   
   for(size_t no=0 ; no<scene.nbObjects() ; ++no) {  
3352      (*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ;      (*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ;
3353    }    }
3354    

Legend:
Removed from v.1.37  
changed lines
  Added in v.1.38

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