/[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.35 by dobj, Fri Sep 12 15:23:32 2003 UTC revision 1.36 by delpinux, Sun Sep 14 17:17:47 2003 UTC
# Line 53  Line 53 
53  #include <HexahedronByEdges.hpp>  #include <HexahedronByEdges.hpp>
54  #include <TetrahedronByEdges.hpp>  #include <TetrahedronByEdges.hpp>
55    
56    #include <MeshExtractor.hpp>
57    
58  #include <set>  #include <set>
59  #include <iostream>  #include <iostream>
60  #include <stack>  #include <stack>
# Line 171  private: Line 173  private:
173    class ObjectToTreat;    class ObjectToTreat;
174    friend class SurfaceMeshGenerator;    friend class SurfaceMeshGenerator;
175    
176    typedef std::map<TinyVector<3,real_t>, std::vector<SurfaceMesh*> > VRRefMesh;    typedef std::map<TinyVector<3,real_t>, ReferenceCounting<SurfaceMesh> > VRRefMesh;
177    
178    typedef std::list<TinyVector<3,Edge::Pair> > EdgePairList;          typedef std::list<TinyVector<3,Edge::Pair> > EdgePairList;      
179    typedef std::list<const Cell*> MotherCellList;    typedef std::list<const Cell*> MotherCellList;
# Line 593  __operationBoolean(ObjectToTreat& O0, Line 595  __operationBoolean(ObjectToTreat& O0,
595                           hexaList2.begin(), hexaList2.end(),                           hexaList2.begin(), hexaList2.end(),
596                           inserter(toTreatHexahedra, toTreatHexahedra.begin()));                           inserter(toTreatHexahedra, toTreatHexahedra.begin()));
597    
598    ffout(3)<<"nb hexa to treat "<<toTreatHexahedra.size()<<"\n";    ffout(4)<<"nb hexa to treat "<<toTreatHexahedra.size()<<"\n";
599        
600    __calculateIntersection<booleanTest>(O0,O1,O2, toTreatHexahedra);    __calculateIntersection<booleanTest>(O0,O1,O2, toTreatHexahedra);
601  }  }
# Line 613  __calculateIntersection(ObjectToTreat& O Line 615  __calculateIntersection(ObjectToTreat& O
615    //create mesh intersection for the object 0 and 1    //create mesh intersection for the object 0 and 1
616    __createTrianglesIntersection<booleanTest>(0, O1, O2, toTreatHexahedra,    __createTrianglesIntersection<booleanTest>(0, O1, O2, toTreatHexahedra,
617                                               triangleListIntersectionNew, listVertexIntersectionNew);                                               triangleListIntersectionNew, listVertexIntersectionNew);
618    ffout(3)<<"nb triangles in intersection 0 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;    ffout(4)<<"nb triangles in intersection 0 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;
619    __createTrianglesIntersection<booleanTest>(1, O2, O1, toTreatHexahedra,    __createTrianglesIntersection<booleanTest>(1, O2, O1, toTreatHexahedra,
620                                               triangleListIntersectionNew, listVertexIntersectionNew);                                               triangleListIntersectionNew, listVertexIntersectionNew);
621    ffout(3)<<"nb triangles in intersection 1 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;    ffout(4)<<"nb triangles in intersection 1 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;
622    
623    pairTriangleToIntersectionPoints.clear();    pairTriangleToIntersectionPoints.clear();
624        
# Line 689  void SurfaceMeshGenerator::Internals::__ Line 691  void SurfaceMeshGenerator::Internals::__
691    ntr+=listOfVertexMesh.size();    ntr+=listOfVertexMesh.size();
692        
693    s_mesh.setNumberOfVertices(ntr);    s_mesh.setNumberOfVertices(ntr);
694    ffout(3)<<"nb tot vertices "<<s_mesh.numberOfVertices()<<"\n"<<std::flush;    ffout(4)<<"nb tot vertices "<<s_mesh.numberOfVertices()<<"\n"<<std::flush;
695        
696    //! copies vertices into the s_mesh.    //! copies vertices into the s_mesh.
697    int i = 0;    int i = 0;
# Line 717  void SurfaceMeshGenerator::Internals::__ Line 719  void SurfaceMeshGenerator::Internals::__
719    //if(nobjectToTreat==0){    //if(nobjectToTreat==0){
720    ncell+=triangleList.size();    ncell+=triangleList.size();
721    //}    //}
722    //  ffout(3)<<"ncell "<<ncell<<" n0 "<<n0<<" n1 "<<n1<<"\n";    //  ffout(4)<<"ncell "<<ncell<<" n0 "<<n0<<" n1 "<<n1<<"\n";
723        
724    s_mesh.setNumberOfCells(ncell);    s_mesh.setNumberOfCells(ncell);
725    ffout(3)<<"nb tot cells "<<s_mesh.numberOfCells()<<" \n"<<std::flush;    ffout(4)<<"nb tot cells "<<s_mesh.numberOfCells()<<" \n"<<std::flush;
726        
727    for(size_t size=0 ; size< triangleList.size() ; ++size) {    for(size_t size=0 ; size< triangleList.size() ; ++size) {
728      const Triangle& T=triangleList[size];      const Triangle& T=triangleList[size];
# Line 822  __calculatePointsIntersection(const Obje Line 824  __calculatePointsIntersection(const Obje
824          }          }
825        }        }
826      } else {      } else {
827        //ffout(3)<<"pas d'intersection dans l'hexa\n";        //ffout(4)<<"pas d'intersection dans l'hexa\n";
828      }      }
829    }    }
830  }  }
# Line 1059  __DeterminatePoint(const size_t& ncase, Line 1061  __DeterminatePoint(const size_t& ncase,
1061          if(inV01 > epsilon and inV02 > epsilon and inV12 > epsilon ) {          if(inV01 > epsilon and inV02 > epsilon and inV12 > epsilon ) {
1062            __InTriangle(P,V,num);            __InTriangle(P,V,num);
1063            if(num==3) {            if(num==3) {
1064              //ffout(3)<<"ajout du point cas 2\n";              //ffout(4)<<"ajout du point cas 2\n";
1065              //ffout(3)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n";              //ffout(4)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n";
1066              //listVertexIntersectionNew.push_back(new Vertex (P));              //listVertexIntersectionNew.push_back(new Vertex (P));
1067              PIntersection PIn;              PIntersection PIn;
1068  //          if(!(norm2>epsilon)) {  //          if(!(norm2>epsilon)) {
# Line 1152  __inout(const size_t& numobject, Line 1154  __inout(const size_t& numobject,
1154    size_t& refVertex1=(*edgesRefVertex[numobject])[V1];    size_t& refVertex1=(*edgesRefVertex[numobject])[V1];
1155    
1156    if(refVertex0+refVertex1==4 and edgeCut==1) {    if(refVertex0+refVertex1==4 and edgeCut==1) {
1157      ffout(3)<<"warning edge ref 2 cut \n";      ffout(4)<<"warning edge ref 2 cut \n";
1158      ffout(3)<<(*V0)[0]<<" "<<(*V0)[1]<<" "<<(*V0)[2]<<" \n";      ffout(4)<<(*V0)[0]<<" "<<(*V0)[1]<<" "<<(*V0)[2]<<" \n";
1159      ffout(3)<<(*V1)[0]<<" "<<(*V1)[1]<<" "<<(*V1)[2]<<" \n";      ffout(4)<<(*V1)[0]<<" "<<(*V1)[1]<<" "<<(*V1)[2]<<" \n";
1160      refVertex0=0;      refVertex0=0;
1161      refVertex1=0;      refVertex1=0;
1162    } else {    } else {
# Line 1171  __createPointIntersection(std::list<Tria Line 1173  __createPointIntersection(std::list<Tria
1173                            std::list<Triangle*>::iterator currentTriangle,                            std::list<Triangle*>::iterator currentTriangle,
1174                            PIntersection& listVertexIntersectionNew)                            PIntersection& listVertexIntersectionNew)
1175  {      {    
1176    //ffout(3)<< "createpointintersection "<<numobject<<" "<<objectNumber<<"\n";    //ffout(4)<< "createpointintersection "<<numobject<<" "<<objectNumber<<"\n";
1177    //ffout(3)<<"*************************\n";    //ffout(4)<<"*************************\n";
1178    
1179    PairTriangleNew pTriangle;    PairTriangleNew pTriangle;
1180    pTriangle.first=(*currentTriangle1);    pTriangle.first=(*currentTriangle1);
# Line 1185  __createPointIntersection(std::list<Tria Line 1187  __createPointIntersection(std::list<Tria
1187    const TinyVector<3,size_t >& pintercut=Pinter.cutTriangle1();    const TinyVector<3,size_t >& pintercut=Pinter.cutTriangle1();
1188    
1189    if(pintercut[0]+pintercut[1]+pintercut[2]!=0) {    if(pintercut[0]+pintercut[1]+pintercut[2]!=0) {
1190      //ffout(3)<<"le tr est cut\n";      //ffout(4)<<"le tr est cut\n";
1191      assert(pairTriangleToIntersectionPoints.find(pTriangle)==pairTriangleToIntersectionPoints.end());      assert(pairTriangleToIntersectionPoints.find(pTriangle)==pairTriangleToIntersectionPoints.end());
1192      pairTriangleToIntersectionPoints[pTriangle] = Pinter;      pairTriangleToIntersectionPoints[pTriangle] = Pinter;
1193    } else {    } else {
1194      if(Pinter.size()!=0) {      if(Pinter.size()!=0) {
1195        //ffout(3)<<"rajout2 \n";        //ffout(4)<<"rajout2 \n";
1196        pairTriangleToIntersectionPoints[pTriangle] = Pinter;        pairTriangleToIntersectionPoints[pTriangle] = Pinter;
1197      }      }
1198    }    }
# Line 1325  __createCase1(int ncase, Line 1327  __createCase1(int ncase,
1327  //#warning Reference not set.  //#warning Reference not set.
1328          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1329        } else {        } else {
1330          ffout(3) <<"pbs 10\n"<<std::flush;          ffout(4) <<"pbs 10\n"<<std::flush;
1331          ffout(3)<<V0<<"\n";          ffout(4)<<V0<<"\n";
1332          ffout(3)<<V1<<"\n";          ffout(4)<<V1<<"\n";
1333          ffout(3)<<V2<<"\n";          ffout(4)<<V2<<"\n";
1334        }        }
1335      } else {      } else {
1336        if(edgesCut[1]==1) {        if(edgesCut[1]==1) {
1337          ffout(3)<<"pbs 11\n"<<std::flush;          ffout(4)<<"pbs 11\n"<<std::flush;
1338          ffout(3)<<V0<<"\n";          ffout(4)<<V0<<"\n";
1339          ffout(3)<<V1<<"\n";          ffout(4)<<V1<<"\n";
1340          ffout(3)<<V2<<"\n";          ffout(4)<<V2<<"\n";
1341          ffout(3)<<ncase<<"\n";          ffout(4)<<ncase<<"\n";
1342          ffout(3)<<__determinateNumber(vertexNum[1],pointsIntersection)<<"\n";          ffout(4)<<__determinateNumber(vertexNum[1],pointsIntersection)<<"\n";
1343        } else {        } else {
1344          ffout(3) <<"pbs 111\n";          ffout(4) <<"pbs 111\n";
1345        }        }
1346      }      }
1347      break;      break;
# Line 1355  __createCase1(int ncase, Line 1357  __createCase1(int ncase,
1357          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);
1358          __addTriangle(Triangle(A,D,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,D,C,K.reference()),cell,triangleListIntersectionNew);
1359        } else {        } else {
1360          ffout(3)<<"-------- warning trou in 0\n"<<std::flush;          ffout(4)<<"-------- warning trou in 0\n"<<std::flush;
1361          ffout(3)<<V0<<"\n";          ffout(4)<<V0<<"\n";
1362          ffout(3)<<V1<<"\n";          ffout(4)<<V1<<"\n";
1363          ffout(3)<<V2<<"\n";          ffout(4)<<V2<<"\n";
1364  //#warning Reference not set.  //#warning Reference not set.
1365          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);
1366        }        }
1367      } else {      } else {
1368        if(edgesCut[1]==1) {        if(edgesCut[1]==1) {
1369          ffout(3)<<"-------- warning trou in\n"<<std::flush;          ffout(4)<<"-------- warning trou in\n"<<std::flush;
1370          const Vertex& B=__determinateNumber(vertexNum[1],pointsIntersection);          const Vertex& B=__determinateNumber(vertexNum[1],pointsIntersection);
1371  //#warning Reference not set.  //#warning Reference not set.
1372          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,D,K.reference()),cell,triangleListIntersectionNew);
1373        } else {        } else {
1374          ffout(3) <<"pbs 1\n"<<std::flush;          ffout(4) <<"pbs 1\n"<<std::flush;
1375        }        }
1376      }      }
1377      break;      break;
1378    }    }
1379    default: {    default: {
1380  #warning is it true? case where only one edge is cut?  #warning is it true? case where only one edge is cut?
1381      ffout(3) << numberPointsInterior<<" be careful 1\n"<<std::flush;      ffout(4) << numberPointsInterior<<" be careful 1\n"<<std::flush;
1382        //case 1 point inside and more than 1 point in the triangle        //case 1 point inside and more than 1 point in the triangle
1383      __createByEdges(K, cell, triangleListIntersectionNew);      __createByEdges(K, cell, triangleListIntersectionNew);
1384    }    }
# Line 1442  __createCase2(int ncase, Line 1444  __createCase2(int ncase,
1444          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1445          __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew);
1446        } else {        } else {
1447          // ffout(3) <<"pbs 20\n";          // ffout(4) <<"pbs 20\n";
1448  //#warning Reference not set.  //#warning Reference not set.
1449          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1450        }        }
1451      } else {      } else {
1452        if(edgesCut[1]==1) {        if(edgesCut[1]==1) {
1453          // ffout(3) <<"pbs 210\n";          // ffout(4) <<"pbs 210\n";
1454          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);
1455  //#warning Reference not set.  //#warning Reference not set.
1456          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew);
1457        } else {        } else {
1458          ffout(3) <<"pbs 21\n"<<std::flush;          ffout(4) <<"pbs 21\n"<<std::flush;
1459          ffout(3)<<V0<<"\n";          ffout(4)<<V0<<"\n";
1460          ffout(3)<<V1<<"\n";          ffout(4)<<V1<<"\n";
1461          ffout(3)<<V2<<"\n";          ffout(4)<<V2<<"\n";
1462        }        }
1463      }      }
1464      break;      break;
# Line 1491  __createCase2(int ncase, Line 1493  __createCase2(int ncase,
1493    }    }
1494    default: {    default: {
1495      //POUR STEPH :  peut generer des tr plats      //POUR STEPH :  peut generer des tr plats
1496      ffout(3) << numberPointsInterior <<"be careful 2\n"<<std::flush;      ffout(4) << numberPointsInterior <<"be careful 2\n"<<std::flush;
1497      //     ffout(3)<<V0<<"\n";      //     ffout(4)<<V0<<"\n";
1498      //   ffout(3)<<V1<<"\n";      //   ffout(4)<<V1<<"\n";
1499      // ffout(3)<<V2<<"\n";      // ffout(4)<<V2<<"\n";
1500      TinyVector<10,const Vertex*> P,Ptemp;      TinyVector<10,const Vertex*> P,Ptemp;
1501      size_t i=0;      size_t i=0;
1502      for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();      for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();
# Line 1532  __createCase2(int ncase, Line 1534  __createCase2(int ncase,
1534            Ptemp[0]=P[num];            Ptemp[0]=P[num];
1535            P=Ptemp;            P=Ptemp;
1536            --size;            --size;
1537            // ffout(3)<<"size = "<<size<<"\n";            // ffout(4)<<"size = "<<size<<"\n";
1538          }          }
1539  //#warning Reference not set.  //#warning Reference not set.
1540          __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew);
1541          __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew);
1542          //__addTriangle(A,B,D,cell);          //__addTriangle(A,B,D,cell);
1543        } else {        } else {
1544          ffout(3)<<"une seule arete cut pbs\n";          ffout(4)<<"une seule arete cut pbs\n";
1545        }        }
1546      } else {      } else {
1547        ffout(3)<<"une seule arete cut pbs2\n";        ffout(4)<<"une seule arete cut pbs2\n";
1548      }      }
1549    }    }
1550    }    }
# Line 1592  __createLocalListIntersection(const size Line 1594  __createLocalListIntersection(const size
1594          //detection tr plat          //detection tr plat
1595          size_t isDegenerate=0;          size_t isDegenerate=0;
1596          if(__isDegenerate(*(*jt0))) {          if(__isDegenerate(*(*jt0))) {
1597            // ffout(3)<<"degenerate triangle\n";            // ffout(4)<<"degenerate triangle\n";
1598            isDegenerate=1;            isDegenerate=1;
1599          }          }
1600          if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) {
# Line 1600  __createLocalListIntersection(const size Line 1602  __createLocalListIntersection(const size
1602            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1];
1603            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))
1604               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {
1605              //ffout(3)<<"inter confondu avec arete\n";              //ffout(4)<<"inter confondu avec arete\n";
1606              isDegenerate=1;              isDegenerate=1;
1607            }            }
1608          }          }
# Line 1648  __createLocalListIntersection(const size Line 1650  __createLocalListIntersection(const size
1650            size_t r=0;            size_t r=0;
1651            size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2];            size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2];
1652            if(sum>3) {            if(sum>3) {
1653              ffout(3)<<"sum "<<sum<<"\n"<<std::flush;              ffout(4)<<"sum "<<sum<<"\n"<<std::flush;
1654            }            }
1655    
1656            switch (sum) {            switch (sum) {
# Line 1673  __createLocalListIntersection(const size Line 1675  __createLocalListIntersection(const size
1675              break;              break;
1676            }            }
1677            default: {            default: {
1678              ffout(3) << "pbs sum = "<<sum<<" size "              ffout(4) << "pbs sum = "<<sum<<" size "
1679                       << pairTriangleToIntersectionPoints[pairTriangle].size()<<" \n";                       << pairTriangleToIntersectionPoints[pairTriangle].size()<<" \n";
1680              ffout(3) << K(0) << "\n";              ffout(4) << K(0) << "\n";
1681              ffout(3) << K(1) << "\n";              ffout(4) << K(1) << "\n";
1682              ffout(3) << K(2) << "\n";              ffout(4) << K(2) << "\n";
1683              ffout(3) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n";              ffout(4) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n";
1684            }            }
1685            }            }
1686            if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r])            if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r])
# Line 1688  __createLocalListIntersection(const size Line 1690  __createLocalListIntersection(const size
1690            }            }
1691          }          }
1692        } else {        } else {
1693          // ffout(3) <<"pasintersecte\n";          // ffout(4) <<"pasintersecte\n";
1694        }        }
1695      }      }
1696    }    }
# Line 1740  __determinateEdgeCut(const size_t& numob Line 1742  __determinateEdgeCut(const size_t& numob
1742          }          }
1743        }        }
1744        else {        else {
1745          // ffout(3)<<"la paire de triangle n'existe pas!\n";          // ffout(4)<<"la paire de triangle n'existe pas!\n";
1746        }        }
1747      }      }
1748    }    }
# Line 1938  __createNotIn(const TriangleCut& K,const Line 1940  __createNotIn(const TriangleCut& K,const
1940    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {
1941      T[0]=(*vertexInTriangles.find(P[0])).second[0];      T[0]=(*vertexInTriangles.find(P[0])).second[0];
1942    } else {    } else {
1943      ffout(3)<<"pbs 0 existe pas\n";      ffout(4)<<"pbs 0 existe pas\n";
1944    }    }
1945    
1946    size_t b=0;    size_t b=0;
# Line 1960  __createNotIn(const TriangleCut& K,const Line 1962  __createNotIn(const TriangleCut& K,const
1962          P[b+1]=VV[0];          P[b+1]=VV[0];
1963        }        }
1964      } else {      } else {
1965        ffout(3)<<"pbs 1 existe pas\n";        ffout(4)<<"pbs 1 existe pas\n";
1966        b=28;        b=28;
1967      }      }
1968      TinyVector<2,const Triangle*> T2;      TinyVector<2,const Triangle*> T2;
# Line 1979  __createNotIn(const TriangleCut& K,const Line 1981  __createNotIn(const TriangleCut& K,const
1981      }      }
1982      ++b;      ++b;
1983    }    }
1984    if(b==29) ffout(3)<<"createnotin b ="<<b<<"\n";    if(b==29) ffout(4)<<"createnotin b ="<<b<<"\n";
1985  }  }
1986    
1987  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
# Line 1995  __createNotIn2(const TriangleCut& K,cons Line 1997  __createNotIn2(const TriangleCut& K,cons
1997        place0=2;        place0=2;
1998      }      }
1999    
2000    //ffout(3)<<"place = "<<place0<<"\n";    //ffout(4)<<"place = "<<place0<<"\n";
2001    const Vertex* Pend=K.pointsIntersection[place0][1];    const Vertex* Pend=K.pointsIntersection[place0][1];
2002    TinyVector<30,const Vertex*> P;    TinyVector<30,const Vertex*> P;
2003    TinyVector<30,const Triangle*> T;    TinyVector<30,const Triangle*> T;
# Line 2003  __createNotIn2(const TriangleCut& K,cons Line 2005  __createNotIn2(const TriangleCut& K,cons
2005    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {
2006      T[0]=(*vertexInTriangles.find(P[0])).second[0];      T[0]=(*vertexInTriangles.find(P[0])).second[0];
2007    } else {    } else {
2008      ffout(3)<<"pbs 0 existe pas\n";      ffout(4)<<"pbs 0 existe pas\n";
2009    }    }
2010    
2011    size_t b=0;    size_t b=0;
2012    while(P[b]!=Pend and b<29) {    while(P[b]!=Pend and b<29) {
2013      //ffout(3)<<"------------------- b "<<b<<"\n";      //ffout(4)<<"------------------- b "<<b<<"\n";
2014      if(triangleWithVertex.find(T[b])!=triangleWithVertex.end()) {      if(triangleWithVertex.find(T[b])!=triangleWithVertex.end()) {
2015        TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[b])).second;        TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[b])).second;
2016        if(VV[0]==P[b]) {        if(VV[0]==P[b]) {
2017          if(Pend!=VV[1]) {          if(Pend!=VV[1]) {
2018            __addTriangle(Triangle(*Pend,*P[b],*VV[1],K.reference()),cell,triangleListIntersectionNew);            __addTriangle(Triangle(*Pend,*P[b],*VV[1],K.reference()),cell,triangleListIntersectionNew);
2019            //  ffout(3)<<"1 "<<*Pend<<"\n";            //  ffout(4)<<"1 "<<*Pend<<"\n";
2020            //  ffout(3)<<*P[b]<<"\n";            //  ffout(4)<<*P[b]<<"\n";
2021            //  ffout(3)<<*VV[1]<<"\n";            //  ffout(4)<<*VV[1]<<"\n";
2022          }          }
2023          P[b+1]=VV[1];          P[b+1]=VV[1];
2024        } else {        } else {
2025          if(Pend!=VV[0]) {          if(Pend!=VV[0]) {
2026              __addTriangle(Triangle(*Pend,*P[b],*VV[0],K.reference()),cell,triangleListIntersectionNew);              __addTriangle(Triangle(*Pend,*P[b],*VV[0],K.reference()),cell,triangleListIntersectionNew);
2027            //ffout(3)<<"2 "<<*Pend<<"\n";            //ffout(4)<<"2 "<<*Pend<<"\n";
2028            //ffout(3)<<*P[b]<<"\n";            //ffout(4)<<*P[b]<<"\n";
2029            //ffout(3)<<*VV[0]<<"\n";            //ffout(4)<<*VV[0]<<"\n";
2030          }          }
2031          P[b+1]=VV[0];          P[b+1]=VV[0];
2032        }        }
2033      } else {      } else {
2034        ffout(3)<<"pbs 1 existe pas\n";        ffout(4)<<"pbs 1 existe pas\n";
2035        b=28;        b=28;
2036      }      }
2037                
# Line 2038  __createNotIn2(const TriangleCut& K,cons Line 2040  __createNotIn2(const TriangleCut& K,cons
2040        T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];        T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];
2041        T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];        T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];
2042      } else {      } else {
2043        ffout(3)<<"points exisste pas \n";        ffout(4)<<"points exisste pas \n";
2044        b=28;        b=28;
2045      }      }
2046            
# Line 2058  __createNotIn2(const TriangleCut& K,cons Line 2060  __createNotIn2(const TriangleCut& K,cons
2060      if(T2[0]==T[b]) {      if(T2[0]==T[b]) {
2061        if(T2[1]==T[b]) {        if(T2[1]==T[b]) {
2062          //point edge          //point edge
2063          //ffout(3)<<"here\n";          //ffout(4)<<"here\n";
2064          if(K.edgecut[0][0]==1 and K.edgecut[0][1]==1 and place0!=0) {          if(K.edgecut[0][0]==1 and K.edgecut[0][1]==1 and place0!=0) {
2065            //ffout(3)<<"here2\n";            //ffout(4)<<"here2\n";
2066            if(P[b+1]==K.pointsIntersection[0][1]) {            if(P[b+1]==K.pointsIntersection[0][1]) {
2067              __addTriangle(Triangle(*Pend,*P[b+1],*K.pointsIntersection[0][0],              __addTriangle(Triangle(*Pend,*P[b+1],*K.pointsIntersection[0][0],
2068                              K.reference()),cell,triangleListIntersectionNew);                              K.reference()),cell,triangleListIntersectionNew);
# Line 2079  __createNotIn2(const TriangleCut& K,cons Line 2081  __createNotIn2(const TriangleCut& K,cons
2081                  T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];                  T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];
2082                  T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];                  T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];
2083                } else {                } else {
2084                  ffout(3)<<"le tr e pas\n";                  ffout(4)<<"le tr e pas\n";
2085                }                }
2086                T[b+1]=T2[0];                T[b+1]=T2[0];
2087              } else              } else
2088                if(P[b+1]!=Pend) {                if(P[b+1]!=Pend) {
2089                  ffout(3)<<"point pas sur edge trou???? \n";                  ffout(4)<<"point pas sur edge trou???? \n";
2090                  ffout(3)<<*P[b+1]<<"\n";                  ffout(4)<<*P[b+1]<<"\n";
2091                  ffout(3)<<*Pend<<"\n";                  ffout(4)<<*Pend<<"\n";
2092                  P[b+1]=Pend;                  P[b+1]=Pend;
2093                }                }
2094          } else {          } else {
# Line 2113  __createNotIn2(const TriangleCut& K,cons Line 2115  __createNotIn2(const TriangleCut& K,cons
2115                }                }
2116              }              }
2117            } else {            } else {
2118              ffout(3)<<"pas trouve l'egde et le point\n";              ffout(4)<<"pas trouve l'egde et le point\n";
2119            }            }
2120          }          }
2121        } else {        } else {
# Line 2124  __createNotIn2(const TriangleCut& K,cons Line 2126  __createNotIn2(const TriangleCut& K,cons
2126      }      }
2127      ++b;      ++b;
2128    }    }
2129    if(b==29) ffout(3)<<"createnotin2 b ="<<b<<"\n";    if(b==29) ffout(4)<<"createnotin2 b ="<<b<<"\n";
2130  }  }
2131    
2132  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
# Line 2156  __createByEdges(const TriangleCut& K,con Line 2158  __createByEdges(const TriangleCut& K,con
2158    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {    if(vertexInTriangles.find(P[0])!=vertexInTriangles.end()) {
2159      T[0]=(*vertexInTriangles.find(P[0])).second[0];      T[0]=(*vertexInTriangles.find(P[0])).second[0];
2160    } else {    } else {
2161      ffout(3)<<"pbs 0 existe pas\n";      ffout(4)<<"pbs 0 existe pas\n";
2162    }    }
2163    
2164    size_t b=0;    size_t b=0;
# Line 2165  __createByEdges(const TriangleCut& K,con Line 2167  __createByEdges(const TriangleCut& K,con
2167        TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[b])).second;        TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[b])).second;
2168        if(VV[0]==P[b]) {        if(VV[0]==P[b]) {
2169          if(VV[1]==P[b]) {          if(VV[1]==P[b]) {
2170            ffout(3)<<"b ="<<b<<" egal\n";            ffout(4)<<"b ="<<b<<" egal\n";
2171            if(K.pointsIntersection[place2][0]==P[b]) {            if(K.pointsIntersection[place2][0]==P[b]) {
2172              P[b+1]=K.pointsIntersection[place2][1];              P[b+1]=K.pointsIntersection[place2][1];
2173              __addTriangle(Triangle(K(in0),*P[b],*P[b+1],K.reference()),cell,triangleListIntersectionNew);              __addTriangle(Triangle(K(in0),*P[b],*P[b+1],K.reference()),cell,triangleListIntersectionNew);
# Line 2174  __createByEdges(const TriangleCut& K,con Line 2176  __createByEdges(const TriangleCut& K,con
2176                P[b+1]=K.pointsIntersection[place2][0];                P[b+1]=K.pointsIntersection[place2][0];
2177                __addTriangle(Triangle(K(in0),*P[b],*P[b+1],K.reference()),cell,triangleListIntersectionNew);                __addTriangle(Triangle(K(in0),*P[b],*P[b+1],K.reference()),cell,triangleListIntersectionNew);
2178              } else {              } else {
2179                ffout(3)<<"pbs pbs\n";                ffout(4)<<"pbs pbs\n";
2180                ffout(3)<<*P[b]<<"\n";                ffout(4)<<*P[b]<<"\n";
2181                P[b+1]=K.pointsIntersection[place2][1];                P[b+1]=K.pointsIntersection[place2][1];
2182                //std::exit(0);                //std::exit(0);
2183              }              }
# Line 2189  __createByEdges(const TriangleCut& K,con Line 2191  __createByEdges(const TriangleCut& K,con
2191          P[b+1]=VV[0];          P[b+1]=VV[0];
2192        }        }
2193      } else {      } else {
2194        ffout(3)<<"pbs 1 existe pas\n";        ffout(4)<<"pbs 1 existe pas\n";
2195        b=28;        b=28;
2196      }      }
2197      TinyVector<2,const Triangle*> T2;      TinyVector<2,const Triangle*> T2;
# Line 2198  __createByEdges(const TriangleCut& K,con Line 2200  __createByEdges(const TriangleCut& K,con
2200        T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];        T2[0]=(*vertexInTriangles.find(P[b+1])).second[0];
2201        T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];        T2[1]=(*vertexInTriangles.find(P[b+1])).second[1];
2202      } else {      } else {
2203        ffout(3)<<"pbs tr existe pas\n";        ffout(4)<<"pbs tr existe pas\n";
2204        b=28;        b=28;
2205      }      }
2206    
2207      if(T2[0]==T[b] and T2[1]==T[b]) {      if(T2[0]==T[b] and T2[1]==T[b]) {
2208        // ffout(3)<<"here0\n";        // ffout(4)<<"here0\n";
2209        //point edge        //point edge
2210        if(P[b+1]!=Pend) {        if(P[b+1]!=Pend) {
2211          if(K.pointsIntersection[place2][0]==P[b+1]) {          if(K.pointsIntersection[place2][0]==P[b+1]) {
# Line 2233  __createByEdges(const TriangleCut& K,con Line 2235  __createByEdges(const TriangleCut& K,con
2235      }      }
2236      ++b;      ++b;
2237    }    }
2238    if(b==29) ffout(3)<<"createbyedges b ="<<b<<"\n";    if(b==29) ffout(4)<<"createbyedges b ="<<b<<"\n";
2239  }  }
2240    
2241  void SurfaceMeshGenerator::Internals::__3pointsintersection(const TriangleCut& K,const Cell* cell,  void SurfaceMeshGenerator::Internals::__3pointsintersection(const TriangleCut& K,const Cell* cell,
# Line 2247  void SurfaceMeshGenerator::Internals::__ Line 2249  void SurfaceMeshGenerator::Internals::__
2249      }      }
2250      if(V[0]!=V[1] and V[1]!=V[2] and V[2]!=V[0]) {      if(V[0]!=V[1] and V[1]!=V[2] and V[2]!=V[0]) {
2251          __addTriangle(Triangle(*V[0],*V[1],*V[2],K.reference()),cell,triangleListIntersectionNew);          __addTriangle(Triangle(*V[0],*V[1],*V[2],K.reference()),cell,triangleListIntersectionNew);
2252          ffout(3)<<"on comble le trou\n"<<std::flush;          ffout(4)<<"on comble le trou\n"<<std::flush;
2253      } else {      } else {
2254          ffout(3)<<"----- deux inter =\n";          ffout(4)<<"----- deux inter =\n";
2255          ffout(3)<<V[0]<<"\n";          ffout(4)<<V[0]<<"\n";
2256          ffout(3)<<V[1]<<"\n";          ffout(4)<<V[1]<<"\n";
2257          ffout(3)<<V[2]<<"\n";          ffout(4)<<V[2]<<"\n";
2258      }      }
2259  }  }
2260  template <typename booleanTest>  template <typename booleanTest>
# Line 2271  __createTrianglesIntersection(const size Line 2273  __createTrianglesIntersection(const size
2273      __constructionFinalMesh(O1,surfmesh);      __constructionFinalMesh(O1,surfmesh);
2274      Connectivity<Triangle> connect(nbcell);      Connectivity<Triangle> connect(nbcell);
2275      ConnectivityBuilder<SurfaceMeshOfTriangles> C(surfmesh,connect);      ConnectivityBuilder<SurfaceMeshOfTriangles> C(surfmesh,connect);
2276    //ffout(3)<<"numero "<<numobject<<" "<<objectNumber<<"\n"<<std::flush;    //ffout(4)<<"numero "<<numobject<<" "<<objectNumber<<"\n"<<std::flush;
2277    size_t objectNumber=0;    size_t objectNumber=0;
2278    if(numobject==0)    if(numobject==0)
2279      objectNumber=1;      objectNumber=1;
# Line 2336  __createTrianglesIntersection(const size Line 2338  __createTrianglesIntersection(const size
2338    __putRefByFront(numobject,O1,O2,surfmesh,connect,toTreatHexahedra);    __putRefByFront(numobject,O1,O2,surfmesh,connect,toTreatHexahedra);
2339        
2340    size_t nbinters=listVertexIntersectionNew.size();    size_t nbinters=listVertexIntersectionNew.size();
2341    ffout(3)<<"size listVertexIntersectionNew "<<nbinters<<"\n"<<std::flush;    ffout(4)<<"size listVertexIntersectionNew "<<nbinters<<"\n"<<std::flush;
2342        
2343    for(std::set<const Cell*>::iterator i=toTreatHexahedra.begin();    for(std::set<const Cell*>::iterator i=toTreatHexahedra.begin();
2344        i!=toTreatHexahedra.end() ; ++i) {        i!=toTreatHexahedra.end() ; ++i) {
# Line 2377  __createTrianglesIntersection(const size Line 2379  __createTrianglesIntersection(const size
2379          switch (numberVertexInDomain) {          switch (numberVertexInDomain) {
2380          case 0: {          case 0: {
2381            if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==3 and vertexInTriangles.size()<3) {            if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==3 and vertexInTriangles.size()<3) {
2382              ffout(3)<<"tous les points d'inter ne sont pas dans la liste\n";              ffout(4)<<"tous les points d'inter ne sont pas dans la liste\n";
2383              __casePinterNotInList(K,*i, triangleListIntersectionNew);              __casePinterNotInList(K,*i, triangleListIntersectionNew);
2384              std::exit(1);              std::exit(1);
2385            } else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) {            } else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) {
# Line 2388  __createTrianglesIntersection(const size Line 2390  __createTrianglesIntersection(const size
2390                  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];
2391                if(vertexInTriangles.size()>3 and numberEdgesCut==1){                if(vertexInTriangles.size()>3 and numberEdgesCut==1){
2392                  //one edge cut but twice                  //one edge cut but twice
2393                  ffout(3)<<"createNotIn\n";                  ffout(4)<<"createNotIn\n";
2394                  //POUR STEPH : createNotIn peut generer des tr plats                  //POUR STEPH : createNotIn peut generer des tr plats
2395                  __createNotIn(K,*i, triangleListIntersectionNew);                  __createNotIn(K,*i, triangleListIntersectionNew);
2396                } else {                } else {
2397                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {                  if(vertexInTriangles.size()>3 and numberEdgesCut==2) {
2398                    //two edge cut but twice                    //two edge cut but twice
2399                    ffout(3)<<"createNotIn2\n";                    ffout(4)<<"createNotIn2\n";
2400                    __createNotIn2(K,*i, triangleListIntersectionNew);                    __createNotIn2(K,*i, triangleListIntersectionNew);
2401                  } else {                  } else {
2402                    if(K.edgecut[0]!=0) {                    if(K.edgecut[0]!=0) {
2403                      if(K.pointsIntersection[0][0]==&V0                      if(K.pointsIntersection[0][0]==&V0
2404                         or K.pointsIntersection[0][0]==&V1                         or K.pointsIntersection[0][0]==&V1
2405                         or K.pointsIntersection[0][0]==&V2 or vertexInTriangles.size()==1) {                         or K.pointsIntersection[0][0]==&V2 or vertexInTriangles.size()==1) {
2406                        // ffout(3)<<"**********normal\n";                        // ffout(4)<<"**********normal\n";
2407                      } else {                      } else {
2408                        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
2409                           and K.edgecut[0][1]+K.edgecut[1][1]+K.edgecut[2][1]==3) {                           and K.edgecut[0][1]+K.edgecut[1][1]+K.edgecut[2][1]==3) {
# Line 2419  __createTrianglesIntersection(const size Line 2421  __createTrianglesIntersection(const size
2421                          }                          }
2422                          if(vertexInTriangles.size()>3 and                          if(vertexInTriangles.size()>3 and
2423                             K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==2){                             K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==2){
2424                             ffout(3)<<"hhhhhhhh\n";                             ffout(4)<<"hhhhhhhh\n";
2425                              ffout(3)<<K(0)<<"\n";                              ffout(4)<<K(0)<<"\n";
2426                              ffout(3)<<K(1)<<"\n";                              ffout(4)<<K(1)<<"\n";
2427                              ffout(3)<<K(2)<<"\n";                              ffout(4)<<K(2)<<"\n";
2428                            //__createNotIn2(K,*i,triangleListIntersectionNew);                            //__createNotIn2(K,*i,triangleListIntersectionNew);
2429                          } else {                          } else {
2430                            if(vertexInTriangles.size()>3 and                            if(vertexInTriangles.size()>3 and
2431                               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) {
2432                              ffout(3)<<"case\n";                              ffout(4)<<"case\n";
2433                              __createNotIn(K,*i,triangleListIntersectionNew);                              __createNotIn(K,*i,triangleListIntersectionNew);
2434                            }                            }
2435                          }                          }
2436                        } else {                        } else {
2437                          if(vertexInTriangles.size()>=3) {                          if(vertexInTriangles.size()>=3) {
2438                            ffout(3)<<"triangle cut but outside1\n";                            ffout(4)<<"triangle cut but outside1\n";
2439                            ffout(3)<<V0<<"\n";                            ffout(4)<<V0<<"\n";
2440                            ffout(3)<<V1<<"\n";                            ffout(4)<<V1<<"\n";
2441                            ffout(3)<<V2<<"\n";                            ffout(4)<<V2<<"\n";
2442                            ffout(3)<<"nb points inter "<<vertexInTriangles.size()<<"\n";                            ffout(4)<<"nb points inter "<<vertexInTriangles.size()<<"\n";
2443                          }                          }
2444                        }                        }
2445                      }                      }
# Line 2446  __createTrianglesIntersection(const size Line 2448  __createTrianglesIntersection(const size
2448                        if(K.pointsIntersection[1][0]==&V0                        if(K.pointsIntersection[1][0]==&V0
2449                           or K.pointsIntersection[1][0]==&V1                           or K.pointsIntersection[1][0]==&V1
2450                           or K.pointsIntersection[1][0]==&V2 or vertexInTriangles.size()<3) {                           or K.pointsIntersection[1][0]==&V2 or vertexInTriangles.size()<3) {
2451                          //  ffout(3)<<"**********normal\n";                          //  ffout(4)<<"**********normal\n";
2452                        } else {                        } else {
2453                          ffout(3)<<"triangle cut but outside2\n";                          ffout(4)<<"triangle cut but outside2\n";
2454                          ffout(3)<<V0<<"\n";                          ffout(4)<<V0<<"\n";
2455                          ffout(3)<<V1<<"\n";                          ffout(4)<<V1<<"\n";
2456                          ffout(3)<<V2<<"\n";                          ffout(4)<<V2<<"\n";
2457                          ffout(3)<<"nb points inter "<<vertexInTriangles.size()<<"\n";                          ffout(4)<<"nb points inter "<<vertexInTriangles.size()<<"\n";
2458                        }                        }
2459                      } else {                      } else {
2460                        if(K.edgecut[2]!=0) {                        if(K.edgecut[2]!=0) {
2461                          if(K.pointsIntersection[2][0]==&V0                          if(K.pointsIntersection[2][0]==&V0
2462                             or K.pointsIntersection[2][0]==&V1                             or K.pointsIntersection[2][0]==&V1
2463                             or K.pointsIntersection[2][0]==&V2 or vertexInTriangles.size()<3) {                             or K.pointsIntersection[2][0]==&V2 or vertexInTriangles.size()<3) {
2464                            //ffout(3)<<"**********normal\n";                            //ffout(4)<<"**********normal\n";
2465                          } else {                          } else {
2466                            ffout(3)<<"triangle cut but outside3\n";                            ffout(4)<<"triangle cut but outside3\n";
2467                            ffout(3)<<V0<<"\n";                            ffout(4)<<V0<<"\n";
2468                            ffout(3)<<V1<<"\n";                            ffout(4)<<V1<<"\n";
2469                            ffout(3)<<V2<<"\n";                            ffout(4)<<V2<<"\n";
2470                            ffout(3)<<"nb points inter "<<vertexInTriangles.size()<<"\n";                            ffout(4)<<"nb points inter "<<vertexInTriangles.size()<<"\n";
2471                          }                          }
2472                        }                        }
2473                      }                      }
# Line 2481  __createTrianglesIntersection(const size Line 2483  __createTrianglesIntersection(const size
2483              if(K.pointsIntersection[0][0]!=K.pointsIntersection[1][0]              if(K.pointsIntersection[0][0]!=K.pointsIntersection[1][0]
2484                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]                 and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]
2485                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {                  and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {
2486                   ffout(3)<<"---------------- 3 edge cut \n";                   ffout(4)<<"---------------- 3 edge cut \n";
2487                  __createByEdges(K,*i,triangleListIntersectionNew);                  __createByEdges(K,*i,triangleListIntersectionNew);
2488              } else {              } else {
2489                  __createListTriangle(K,*i,triangleListIntersectionNew);                  __createListTriangle(K,*i,triangleListIntersectionNew);
# Line 2500  __createTrianglesIntersection(const size Line 2502  __createTrianglesIntersection(const size
2502                __addTriangle(*T,*i,triangleListIntersectionNew);                __addTriangle(*T,*i,triangleListIntersectionNew);
2503              } else {              } else {
2504                  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) {
2505                      ffout(3)<<"cas a traiter-------------\n";                      ffout(4)<<"cas a traiter-------------\n";
2506                  } else {                  } else {
2507                      ffout(3)<<K.edgecut[0][0]<<" "<<K.edgecut[1][0]<<" "<<K.edgecut[2][0]<<"\n";                      ffout(4)<<K.edgecut[0][0]<<" "<<K.edgecut[1][0]<<" "<<K.edgecut[2][0]<<"\n";
2508                      ffout(3)<<"cas pas traite\n";                      ffout(4)<<"cas pas traite\n";
2509                  }                  }
2510              }              }
2511            break;            break;
# Line 2882  __createSurface(Structured3DMesh& SMesh, Line 2884  __createSurface(Structured3DMesh& SMesh,
2884                ++itcell;                ++itcell;
2885              }              }
2886            } else {            } else {
2887                ffout(3)<<"------jobDone false\n";                ffout(4)<<"------jobDone false\n";
2888              SurfaceMeshGenerator::Internals::MotherCellList::iterator itcell              SurfaceMeshGenerator::Internals::MotherCellList::iterator itcell
2889                =cellList.begin();                =cellList.begin();
2890              for (EdgePairList::iterator t = localTriangleList.begin();              for (EdgePairList::iterator t = localTriangleList.begin();
# Line 2907  generatesAllSufaceMeshes(const Problem& Line 2909  generatesAllSufaceMeshes(const Problem&
2909  {  {
2910    Internals::VRRefMesh vrRefMesh;    Internals::VRRefMesh vrRefMesh;
2911    
2912    const Domain& Omega = problem.domain();    const Domain& omega = problem.domain();
2913    
2914    POVRayReferences povRefList;    POVRayReferences povRefList;
2915    
# Line 2939  generatesAllSufaceMeshes(const Problem& Line 2941  generatesAllSufaceMeshes(const Problem&
2941      }      }
2942    }    }
2943    
2944    const Scene& scene =Omega.scene();    const Scene& scene =omega.scene();
2945    
2946      SurfaceMeshOfTriangles omegaMesh;
2947    
2948      this->generateSurfacicMesh(omega,
2949                                 omegaMesh,
2950                                 dynamic_cast<Structured3DMesh&>(M));
2951    
2952      MeshExtractor<SurfaceMeshOfTriangles> extractor(omegaMesh);
2953    
 #warning SHOULD EXTRACT sub-meshes from here.  
2954    for(POVRayReferences::iterator povRef = povRefList.begin();    for(POVRayReferences::iterator povRef = povRefList.begin();
2955        povRef!= povRefList.end(); ++povRef) {        povRef!= povRefList.end(); ++povRef) {
2956      for (size_t i=0; i<scene.nbObjects(); ++i) {      const size_t meshReference = omega.reference(povRef->first);
2957        const Object& O = scene.object(i);      vrRefMesh[povRef->first] = extractor(meshReference);
       if (O.reference() == povRef->first) {  
   
         SurfaceMeshOfTriangles* surfMesh  
           = new SurfaceMeshOfTriangles;  
   
         this->generateSurfacicMesh(Omega,  
                                    *surfMesh,  
                                    dynamic_cast<Structured3DMesh&>(M));  
   
         vrRefMesh[povRef->first].push_back(surfMesh);  
       }  
     }  
2958    }    }
2959    
2960    // Now we must create the association between bc and surfMeshes    // Now we must create the association between bc and surfMeshes
# Line 2988  generatesAllSufaceMeshes(const Problem& Line 2985  generatesAllSufaceMeshes(const Problem&
2985        case (Boundary::povRay): {        case (Boundary::povRay): {
2986          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);
2987          for(size_t k=0; k<bp.nbPOVRef(); ++k) {          for(size_t k=0; k<bp.nbPOVRef(); ++k) {
2988            std::vector<SurfaceMesh*>& refMeshes = vrRefMesh[bp.POVRef(k)];            ReferenceCounting<SurfaceMesh> refMesh = vrRefMesh[bp.POVRef(k)];
2989            for(size_t l=0; l<refMeshes.size(); ++l)            bcMeshAssociation.addPDEBoundaryConditionAndMesh(i,&BC,refMesh);
             bcMeshAssociation.addPDEBoundaryConditionAndMesh(i,&BC,refMeshes[l]);  
2990          }          }
2991          break;          break;
2992        }        }
# Line 3029  generatesAllSufaceMeshes(const Problem& Line 3025  generatesAllSufaceMeshes(const Problem&
3025        case (Boundary::povRay): {        case (Boundary::povRay): {
3026          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);
3027          for(size_t k=0; k<bp.nbPOVRef(); ++k) {          for(size_t k=0; k<bp.nbPOVRef(); ++k) {
3028            std::vector<SurfaceMesh*>& refMeshes = vrRefMesh[bp.POVRef(k)];            ReferenceCounting<SurfaceMesh> refMesh = vrRefMesh[bp.POVRef(k)];
3029            for(size_t l=0; l<refMeshes.size(); ++l)            bcMeshAssociation.bilinearBorderOperatorAdd(*i, refMesh);
             bcMeshAssociation.bilinearBorderOperatorAdd(*i, refMeshes[l]);  
3030          }          }
3031          break;          break;
3032        }        }
# Line 3066  generatesAllSufaceMeshes(const Problem& Line 3061  generatesAllSufaceMeshes(const Problem&
3061        case (Boundary::povRay): {        case (Boundary::povRay): {
3062          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);          const BoundaryPOVRay& bp = dynamic_cast<const BoundaryPOVRay&>(B);
3063          for(size_t k=0; k<bp.nbPOVRef(); ++k) {          for(size_t k=0; k<bp.nbPOVRef(); ++k) {
3064            std::vector<SurfaceMesh*>& refMeshes = vrRefMesh[bp.POVRef(k)];            ReferenceCounting<SurfaceMesh> refMesh = vrRefMesh[bp.POVRef(k)];
3065            for(size_t l=0; l<refMeshes.size(); ++l)              bcMeshAssociation.linearBorderOperatorAdd(*i, refMesh);
             bcMeshAssociation.linearBorderOperatorAdd(*i, refMeshes[l]);  
3066          }          }
3067          break;          break;
3068        }        }
# Line 3201  __generateMesh(const Domain& omega, Line 3195  __generateMesh(const Domain& omega,
3195      __marchingTetrahedra(SMesh, *o, 0);      __marchingTetrahedra(SMesh, *o, 0);
3196    
3197      objectStack.push(o);      objectStack.push(o);
3198      ffout(3) << "Marching cube sur " << objectStack.top() << '\n';      ffout(4) << "Marching cube sur " << objectStack.top() << '\n';
3199    }    }
3200    }    }
3201    
# Line 3360  void plotmedit(const size_t& nobject, Line 3354  void plotmedit(const size_t& nobject,
3354    sortie<<" \n";    sortie<<" \n";
3355    sortie<<"Triangles"<<"\n";    sortie<<"Triangles"<<"\n";
3356    sortie<<s_mesh.numberOfCells()<<"\n";    sortie<<s_mesh.numberOfCells()<<"\n";
3357    ffout(3)<<"fin ecriture vertex\n";    ffout(4)<<"fin ecriture vertex\n";
3358    for (size_t i=0; i<s_mesh.numberOfCells(); ++i) {    for (size_t i=0; i<s_mesh.numberOfCells(); ++i) {
3359      const Triangle& T = s_mesh.cell(i);      const Triangle& T = s_mesh.cell(i);
3360      // ffout(3)<<s_mesh.vertexNumber(T(0))<<" "<<s_mesh.vertexNumber(T(1))<<" "<<s_mesh.//vertexNumber(T(2))<<"\n";      // ffout(4)<<s_mesh.vertexNumber(T(0))<<" "<<s_mesh.vertexNumber(T(1))<<" "<<s_mesh.//vertexNumber(T(2))<<"\n";
3361      sortie<<s_mesh.vertexNumber(T(0))+8*toTreatHexahedra.size()+1<<" "<<s_mesh.vertexNumber(T(1))+8*toTreatHexahedra.size()+1<<" "<<s_mesh.vertexNumber(T(2))+8*toTreatHexahedra.size()+1;      sortie<<s_mesh.vertexNumber(T(0))+8*toTreatHexahedra.size()+1<<" "<<s_mesh.vertexNumber(T(1))+8*toTreatHexahedra.size()+1<<" "<<s_mesh.vertexNumber(T(2))+8*toTreatHexahedra.size()+1;
3362            
3363      // sortie<<3*i+1+8*toTreatHexahedra.size()<<" "<<3*i+2+8*toTreatHexahedra.size()<<" //"<<3*i+3+8*toTreatHexahedra.size();//<<" "<<1<<"\n";      // sortie<<3*i+1+8*toTreatHexahedra.size()<<" "<<3*i+2+8*toTreatHexahedra.size()<<" //"<<3*i+3+8*toTreatHexahedra.size();//<<" "<<1<<"\n";
# Line 3375  void plotmedit(const size_t& nobject, Line 3369  void plotmedit(const size_t& nobject,
3369  //       sortie<<" 4"<<"\n";  //       sortie<<" 4"<<"\n";
3370      sortie << " " << T.reference() << '\n';      sortie << " " << T.reference() << '\n';
3371    }    }
3372    ffout(3)<<"fin ecriture triangles\n";    ffout(4)<<"fin ecriture triangles\n";
3373    sortie<<" \n";    sortie<<" \n";
3374    sortie<<"Hexahedra"<<"\n";    sortie<<"Hexahedra"<<"\n";
3375    sortie<<toTreatHexahedra.size()<<" \n";    sortie<<toTreatHexahedra.size()<<" \n";
# Line 3383  void plotmedit(const size_t& nobject, Line 3377  void plotmedit(const size_t& nobject,
3377    for(size_t i=0;i<toTreatHexahedra.size();i++)    for(size_t i=0;i<toTreatHexahedra.size();i++)
3378      sortie<<8*i+1<<" "<<8*i+2<<" "<<8*i+3<<" "<<8*i+4<<" "<<8*i+5<<" "<<8*i+6<<" "<<8*i+7<<" "<<8*i+8<<" 3"<<"\n";      sortie<<8*i+1<<" "<<8*i+2<<" "<<8*i+3<<" "<<8*i+4<<" "<<8*i+5<<" "<<8*i+6<<" "<<8*i+7<<" "<<8*i+8<<" 3"<<"\n";
3379    sortie<<"End"<<" \n";    sortie<<"End"<<" \n";
3380    ffout(3)<<"fin ecriture intersection.mesh\n";    ffout(4)<<"fin ecriture intersection.mesh\n";
3381  }  }

Legend:
Removed from v.1.35  
changed lines
  Added in v.1.36

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