/[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.24 by delpinux, Mon Jul 28 20:45:00 2003 UTC revision 1.25 by delpinux, Fri Aug 1 18:05:23 2003 UTC
# Line 96  private: Line 96  private:
96      }      }
97    };    };
98    
99      struct IntersectionTest
100      {
101        static bool compute(const Cell& C)
102        {
103          for (size_t i=0; i<C.numberOfVertices(); ++i) {
104            if(C(i).Ref()==0)
105              return false;
106          }
107          return true;
108        }
109      };
110    
111      struct UnionTest
112      {
113        static bool compute(const Cell& C)
114        {
115          for (size_t i=0; i<C.numberOfVertices(); ++i) {
116            if(C(i).Ref()==2) {
117              ffout(0) << "2 trouve\n";
118              return false;
119            }
120          }
121          return true;
122        }
123      };
124    
125    
126    class TriangleCut;    class TriangleCut;
127    class ObjectToTreat;    class ObjectToTreat;
128    friend class SurfaceMeshGenerator;    friend class SurfaceMeshGenerator;
# Line 124  private: Line 151  private:
151                     std::pair<ReferenceCounting<std::vector<TetrahedronByEdges> >,                     std::pair<ReferenceCounting<std::vector<TetrahedronByEdges> >,
152                               ReferenceCounting<std::vector<Edge> > > > HexaTetraAssociation;                               ReferenceCounting<std::vector<Edge> > > > HexaTetraAssociation;
153    
   typedef std::map<Edge::Pair, Vertex*> VerticesList;  
154    typedef std::map<TinyVector<3>, Object*, SurfaceMeshGenerator::Internals::__ltv> ObjectReferences;    typedef std::map<TinyVector<3>, Object*, SurfaceMeshGenerator::Internals::__ltv> ObjectReferences;
155    
156    //! list of cut edges and intersection vertex.    //! list of cut edges and intersection vertex.
157    std::vector<ReferenceCounting<std::map<Edge::Pair, size_t> > > edgesRef;    typedef std::map<Edge::Pair, size_t> EdgesRef;
   
   std::vector<ReferenceCounting<EdgePairList> > triangleListes;  
   std::vector<ReferenceCounting<EdgePairList> > localTriangleListesEdges;  
   EdgePairList localTriangleList;  
158    
159    //! This list is used to provide an orientation to the Surfacic Elements.    //! This list is used to provide an orientation to the Surfacic Elements.
160    std::list<TinyVector<3> > InsideVertexList;    std::list<TinyVector<3> > InsideVertexList;
161    
162    //! list of cut edges and intersection vertex.    //! list of cut edges and intersection vertex.
163    std::vector<ReferenceCounting<VerticesList> > verticesListes;    typedef std::map<Edge::Pair, Vertex*> VerticesList;
164    
165    HexaTetraAssociation hexaTetraAssociation;    HexaTetraAssociation hexaTetraAssociation;
166    std::set<const Cell*> toTreatHexahedra;    std::set<const Cell*> toTreatHexahedra;
# Line 168  private: Line 190  private:
190    std::map<const Triangle*,TinyVector<2,const Vertex*> > triangleWithVertex;    std::map<const Triangle*,TinyVector<2,const Vertex*> > triangleWithVertex;
191    
192    MotherCellList cellList;    MotherCellList cellList;
193    std::vector<ReferenceCounting<MotherCellList> > cellListObject;  
194    TinyVector<3> __splitEdge(const Edge& e,    TinyVector<3> __splitEdge(const Edge& e,
                             const Reference::Representation& ref,  
195                              const Shape& S);                              const Shape& S);
196    
197    void __dataStructureConvertion(const size_t nb);    void __dataStructureConvertion(ObjectToTreat& O,
198                                     EdgePairList& triangleListes,
199                                     VerticesList& verticesListes,
200                                     MotherCellList& cellListObject);
201    
202    void __constructionVerticesList(const ObjectToTreat& O0);    void __constructionVerticesList(const ObjectToTreat& O0);
203    
# Line 185  private: Line 209  private:
209                          ObjectReferences& otherReferences,                          ObjectReferences& otherReferences,
210                          const std::vector<TetrahedronByEdges>::iterator& currentT);                          const std::vector<TetrahedronByEdges>::iterator& currentT);
211    
212    void __calculatePointsIntersection(const Scene& scene,    void __calculatePointsIntersection(const ObjectToTreat& O1,
                                      const ObjectToTreat& O1,  
213                                       const ObjectToTreat& O2);                                       const ObjectToTreat& O2);
214    
215    void __setBoundaryType(const Boundary& B,    void __setBoundaryType(const Boundary& B,
# Line 267  private: Line 290  private:
290    
291    void  __createNotIn2(const TriangleCut& K,const Cell* cell);    void  __createNotIn2(const TriangleCut& K,const Cell* cell);
292    
293      template <typename booleanTest>
294    void __createTrianglesIntersection(const size_t numobject,    void __createTrianglesIntersection(const size_t numobject,
295                                       const ObjectToTreat& O1,                                       const ObjectToTreat& O1,
296                                       const ObjectToTreat& O2);                                       const ObjectToTreat& O2);
297    
298    bool __createTriangleSurface(const size_t& nobject,    bool __createTriangleSurface(VerticesList& verticesListes,
299                                   EdgePairList& localTriangleList,
300                                   EdgesRef& edgesRef,
301                                 const Shape& S ,                                 const Shape& S ,
302                                 std::vector<const Edge*>& cutEdges,                                 std::vector<const Edge*>& cutEdges,
                                const Reference::Representation& ref,  
303                                 const Cell& currentCell);                                 const Cell& currentCell);
304    
305    void __createSurface(Structured3DMesh& SMesh,    void __createSurface(Structured3DMesh& SMesh,
306                         const Shape& S ,                         const Shape& S,
307                         const Reference::Representation& ref,                         EdgePairList& triangleListes,
308                         size_t nobject);                         EdgePairList& localTriangleListesEdges,
309                           VerticesList& verticesListes,
310                           EdgesRef& edgesRef,
311                           MotherCellList& cellListObject);
312    
313    bool __isDegenerate(const Triangle& T);    bool __isDegenerate(const Triangle& T);
314    
# Line 288  private: Line 316  private:
316    
317    TinyVector<3,const Vertex*> __determinatePinterNotInList(const TriangleCut& K, TinyVector<3,size_t>);    TinyVector<3,const Vertex*> __determinatePinterNotInList(const TriangleCut& K, TinyVector<3,size_t>);
318    
319      template <typename booleanTest>
320    void __calculateIntersection(ObjectToTreat& O0,    void __calculateIntersection(ObjectToTreat& O0,
321                                 const ObjectToTreat& O1,                                 const ObjectToTreat& O1,
322                                 const ObjectToTreat& O2,                                 const ObjectToTreat& O2);
                                const Domain& Omega);  
323    
324      template <typename booleanTest>
325    void __operationBoolean(ObjectToTreat& O0,    void __operationBoolean(ObjectToTreat& O0,
                           size_t num,  
326                            const ObjectToTreat& O1,                            const ObjectToTreat& O1,
327                            ObjectToTreat& O2,                            ObjectToTreat& O2);
328                            const Domain& Omega,  
329                            Structured3DMesh& SMesh);    void __showObject(Structured3DMesh& SMesh,
330                          const Object& object, const size_t& level,
331                        std::stack<ReferenceCounting<ObjectToTreat> >& objectStack);
332    
333      ReferenceCounting<Vector<Triangle> >
334      __marchingTetrahedra(Structured3DMesh& SMesh,
335                           ObjectToTreat& O,
336    //                     const Shape& S,
337    //                     const size_t& ref,
338                           size_t nobject);
339    
340        
341    /// @todo FUNCTION TO REMOVE    /// @todo FUNCTION TO REMOVE
342    static void __getIntersectionReferences(const Intersection& I,    static void __getIntersectionReferences(const Intersection& I,
343                                            std::map<TinyVector<3>, Object*, Internals::__ltv>& otherReferences);                                            std::map<TinyVector<3>, Object*, Internals::__ltv>& otherReferences);
# Line 313  public: Line 351  public:
351  };  };
352    
353  class SurfaceMeshGenerator::Internals::ObjectToTreat  class SurfaceMeshGenerator::Internals::ObjectToTreat
354    : public Object  //   : public Object
355  {  {
356    private:
357      ReferenceCounting<Shape> __shape;
358      TinyVector<3, real_t> __reference;
359    
360  public :  public :
361      TinyVector<3, real_t>& reference()
362      {
363        return __reference;
364      }
365    
366      const TinyVector<3, real_t>& reference() const
367      {
368        return __reference;
369      }
370    
371      void setShape(const ReferenceCounting<Shape> s)
372      {
373        __shape = s;
374      }
375    
376      const ReferenceCounting<Shape>& shape() const
377      {
378        assert(__shape != 0);
379        return __shape;
380      }
381    
382      bool inside(const Vertex& V) const
383      {
384        return (*__shape).inside(V);
385      }
386    
387    ReferenceCounting<Vector<Triangle> > trianglelist;    ReferenceCounting<Vector<Triangle> > trianglelist;
388    ReferenceCounting<Vector<Vertex*> > verticeslist;    ReferenceCounting<Vector<Vertex*> > verticeslist;
389    ReferenceCounting< MapCellTriangle > hexalist;    ReferenceCounting< MapCellTriangle > hexalist;
390        
391    const ObjectToTreat& operator=(const ObjectToTreat& O)    const ObjectToTreat& operator=(const ObjectToTreat& O)
392    {    {
393      Object::operator=(O);      __shape = O.__shape;
394        __reference = O.__reference;
395      trianglelist = O.trianglelist;      trianglelist = O.trianglelist;
396      verticeslist = O.verticeslist;      verticeslist = O.verticeslist;
397      hexalist = O.hexalist;      hexalist = O.hexalist;
# Line 331  public : Line 400  public :
400    }    }
401    
402    //constructor    //constructor
403    ObjectToTreat(const Object & O)    ObjectToTreat()
     : Object(O)  
404    {    {
405      ;      ;
406    }    }
407    
408    ObjectToTreat(const ObjectToTreat& O)    ObjectToTreat(const ObjectToTreat& O)
409      : Object(O),      : __shape(O.__shape),
410          __reference(O.__reference),
411        trianglelist(O.trianglelist),        trianglelist(O.trianglelist),
412        verticeslist(O.verticeslist),        verticeslist(O.verticeslist),
413        hexalist(O.hexalist)        hexalist(O.hexalist)
# Line 346  public : Line 415  public :
415      ;      ;
416    }    }
417    
   ObjectToTreat(ReferenceCounting<Vector<Triangle> > tr,  
                 ReferenceCounting<Vector<Vertex*> > ver,  
                 ReferenceCounting< MapCellTriangle > hex,  
                 Object & O)  
     : Object(O),  
       trianglelist(tr),  
       verticeslist(ver),  
       hexalist(hex)  
   {  
     ;  
   }  
   
418    ~ObjectToTreat()    ~ObjectToTreat()
419    {    {
420      ;      ;
# Line 446  __setBoundaryType(const Boundary& B, Line 503  __setBoundaryType(const Boundary& B,
503  TinyVector<3, real_t>  TinyVector<3, real_t>
504  SurfaceMeshGenerator::Internals::  SurfaceMeshGenerator::Internals::
505  __splitEdge(const Edge& e,  __splitEdge(const Edge& e,
             const Reference::Representation& ref,  
506              const Shape& S)              const Shape& S)
507  {  {
508    int in = -1;          // number of the vertex inside    int in = -1;          // number of the vertex inside
509    int out = -1;         // same thing for outside    int out = -1;         // same thing for outside
510    
511    for (int j=0; j<2; j++) {    for (int j=0; j<2; j++) {
512      if (!e(j).Ref().isSet(ref)) {      if (e(j).Ref() != 1) {
513        out = j;        out = j;
514      } else {      } else {
515        in = j;        in = j;
# Line 476  __splitEdge(const Edge& e, Line 532  __splitEdge(const Edge& e,
532      }      }
533    }    }
534    
535    if(!S.inside(vs))    return vs;
     return vs;  
   else  
     if(!S.inside(vi))  
       return vi;  
     else  
       return vo;  
536  }  }
537    
538    template <typename booleanTest>
539  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
540  __operationBoolean(ObjectToTreat& O0,  __operationBoolean(ObjectToTreat& O0,
                    size_t num,  
541                     const ObjectToTreat& O1,                     const ObjectToTreat& O1,
542                     ObjectToTreat& O2,                     ObjectToTreat& O2)
                    const Domain& Omega,  
                    Structured3DMesh& SMesh)  
543  {  {
   const Scene& scene = Omega.scene();  
   //const Shape& S=(*O2.shape());  
       
   for(size_t n = 0; n<scene.nbObjects(); ++n) {  
     Reference::Representation otherRef;  
     otherRef.resize(scene.nbObjects());  
     if (scene.object(n).reference() == (O2.reference())) {  
       otherRef[n] = true;  
       //create surface objects  
       __createSurface(SMesh,*(scene.object(n).shape()),otherRef,num);  
     }  
   }  
   
   __dataStructureConvertion(num);  
   
544    std::set<const Cell*> hexaList1;    std::set<const Cell*> hexaList1;
545    std::set<const Cell*> hexaList2;    std::set<const Cell*> hexaList2;
546    
# Line 522  __operationBoolean(ObjectToTreat& O0, Line 555  __operationBoolean(ObjectToTreat& O0,
555                           hexaList2.begin(), hexaList2.end(),                           hexaList2.begin(), hexaList2.end(),
556                           inserter(toTreatHexahedra, toTreatHexahedra.begin()));                           inserter(toTreatHexahedra, toTreatHexahedra.begin()));
557    
   
558    ffout(0)<<"nb hexa to treat "<<toTreatHexahedra.size()<<"\n";    ffout(0)<<"nb hexa to treat "<<toTreatHexahedra.size()<<"\n";
559        
560    __calculateIntersection(O0,O1,O2,Omega);    __calculateIntersection<booleanTest>(O0,O1,O2);
561  }  }
562    
563    template <typename booleanTest>
564  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
565  __calculateIntersection(ObjectToTreat& O0,  __calculateIntersection(ObjectToTreat& O0,
566                          const ObjectToTreat& O1,                          const ObjectToTreat& O1,
567                          const ObjectToTreat& O2,                          const ObjectToTreat& O2)
                         const Domain& Omega)  
568  {  {
569    const Scene& scene = Omega.scene();    __calculatePointsIntersection(O1,O2);
570      
   __calculatePointsIntersection(scene,O1,O2);  
571    //create mesh intersection for the object 0 and 1    //create mesh intersection for the object 0 and 1
572    __createTrianglesIntersection(0,O1,O2);    __createTrianglesIntersection<booleanTest>(0,O1,O2);
573    ffout(0)<<"nb triangles in intersection 0 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;    ffout(0)<<"nb triangles in intersection 0 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;
574    __createTrianglesIntersection(1,O2,O1);    __createTrianglesIntersection<booleanTest>(1,O2,O1);
575    ffout(0)<<"nb triangles in intersection 1 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;    ffout(0)<<"nb triangles in intersection 1 "<<triangleListIntersectionNew.size()<<"\n"<<std::flush;
576        
577    //triangle from intersection of objects 0-1 in O0    //triangle from intersection of objects 0-1 in O0
# Line 573  __createCutEdges(const Scene& scene, Line 604  __createCutEdges(const Scene& scene,
604          otherRef.resize(scene.nbObjects());          otherRef.resize(scene.nbObjects());
605          if (scene.object(n).reference() == ((*i).first)) {          if (scene.object(n).reference() == ((*i).first)) {
606            otherRef[n] = true;            otherRef[n] = true;
607            if ((e(0).Ref().isSet(otherRef)) xor (e(1).Ref().isSet(otherRef))) {            if (e(0).Ref() != e(1).Ref()) {
608              (*cutEdges[num]).push_back(&e);              (*cutEdges[num]).push_back(&e);
609            }            }
610          }          }
# Line 614  void SurfaceMeshGenerator::Internals::__ Line 645  void SurfaceMeshGenerator::Internals::__
645  void SurfaceMeshGenerator::Internals::__constructionFinalMesh(const ObjectToTreat& O0,  void SurfaceMeshGenerator::Internals::__constructionFinalMesh(const ObjectToTreat& O0,
646                                                                SurfaceMeshOfTriangles& s_mesh) {                                                                SurfaceMeshOfTriangles& s_mesh) {
647    
648      __constructionVerticesList(O0);
649    
650    size_t ntr=0;    size_t ntr=0;
651        
652    //ntr+=listVertexFinal.size();    //ntr+=listVertexFinal.size();
# Line 691  void SurfaceMeshGenerator::Internals::__ Line 724  void SurfaceMeshGenerator::Internals::__
724    // }    // }
725  }  }
726    
727  void SurfaceMeshGenerator::Internals::__dataStructureConvertion(const size_t numObj)  void SurfaceMeshGenerator::Internals::__dataStructureConvertion(ObjectToTreat& O,
728                                                                    EdgePairList& triangleListes,
729                                                                    VerticesList& verticesListes,
730                                                                    MotherCellList& cellListObject)
731  {  {
732    //for (size_t numObj = 0; numObj<nb; ++numObj) {    //for (size_t numObj = 0; numObj<nb; ++numObj) {
733    // Data structure convertion    // Data structure convertion
   ObjectToTreat& O=(*listOfObjectToTreat[numObj]);  
734    {    {
735  #warning keep this ?  #warning keep this ?
736      size_t n=0;      size_t n=0;
737      O.verticeslist      O.verticeslist
738        = new Vector<Vertex*>((*verticesListes[numObj]).size());        = new Vector<Vertex*>(verticesListes.size());
739      Vector<Vertex*>& vertexListbis = (*O.verticeslist);      Vector<Vertex*>& vertexListbis = (*O.verticeslist);
740      for (SurfaceMeshGenerator::Internals::VerticesList::iterator      for (SurfaceMeshGenerator::Internals::VerticesList::iterator
741             i = (*verticesListes[numObj]).begin();             i = verticesListes.begin();
742           i != (*verticesListes[numObj]).end(); ++i, ++n) {           i != verticesListes.end(); ++i, ++n) {
743        vertexListbis[n] = (*i).second;        vertexListbis[n] = (*i).second;
744      }      }
745    }    }
# Line 716  void SurfaceMeshGenerator::Internals::__ Line 751  void SurfaceMeshGenerator::Internals::__
751      std::map<const Cell*, std::list<Triangle*> >& hexaToTrianglebis=(*O.hexalist);      std::map<const Cell*, std::list<Triangle*> >& hexaToTrianglebis=(*O.hexalist);
752            
753      O.trianglelist      O.trianglelist
754        = new Vector<Triangle> ((*triangleListes[numObj]).size());        = new Vector<Triangle> (triangleListes.size());
755      Vector<Triangle>& triangleListbis = (*O.trianglelist);      Vector<Triangle>& triangleListbis = (*O.trianglelist);
756      SurfaceMeshGenerator::Internals::MotherCellList::iterator      SurfaceMeshGenerator::Internals::MotherCellList::iterator
757        itcell=(*cellListObject[numObj]).begin();        itcell=cellListObject.begin();
758            
759      for (SurfaceMeshGenerator::Internals::EdgePairList::iterator      for (SurfaceMeshGenerator::Internals::EdgePairList::iterator
760             i = (*triangleListes[numObj]).begin();             i = triangleListes.begin();
761           i != (*triangleListes [numObj]).end(); ++i, ++n) {           i != triangleListes.end(); ++i, ++n) {
762        SurfaceMeshGenerator::Internals::VerticesList& V = (*verticesListes[numObj]);        SurfaceMeshGenerator::Internals::VerticesList& V = verticesListes;
763        Triangle T(* V[(*i)[0]],        Triangle T(* V[(*i)[0]],
764                   * V[(*i)[1]],                   * V[(*i)[1]],
765                   * V[(*i)[2]], 1);                   * V[(*i)[2]], 1);
# Line 736  void SurfaceMeshGenerator::Internals::__ Line 771  void SurfaceMeshGenerator::Internals::__
771      }      }
772    }    }
773        
774    (*verticesListes[numObj]).clear();    verticesListes.clear();
775    (*triangleListes[numObj]).clear();    triangleListes.clear();
776    //}    //}
777  }  }
778    
779  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
780  __calculatePointsIntersection(const Scene& scene,  __calculatePointsIntersection(const ObjectToTreat& O1,
                               const ObjectToTreat& O1,  
781                                const ObjectToTreat& O2)                                const ObjectToTreat& O2)
782  {  {
783    size_t nobject=scene.nbObjects();    MapCellTriangle hexaToTriangle0=*(O1.hexalist);
784        MapCellTriangle hexaToTriangle1=*(O2.hexalist);
   if(0< nobject and 1<nobject) {  
     MapCellTriangle hexaToTriangle0=*(O1.hexalist);  
     MapCellTriangle hexaToTriangle1=*(O2.hexalist);  
785            
786      for(std::set<const Cell*>::iterator i=toTreatHexahedra.begin();    for(std::set<const Cell*>::iterator i=toTreatHexahedra.begin();
787          i!=toTreatHexahedra.end(); ++i) {        i!=toTreatHexahedra.end(); ++i) {
788        MapCellTriangle::iterator it0=hexaToTriangle0.find(*i);      MapCellTriangle::iterator it0=hexaToTriangle0.find(*i);
789        MapCellTriangle::iterator it1=hexaToTriangle1.find(*i);      MapCellTriangle::iterator it1=hexaToTriangle1.find(*i);
790        if(it0!=hexaToTriangle0.end() and it1!=hexaToTriangle1.end()) {      if(it0!=hexaToTriangle0.end() and it1!=hexaToTriangle1.end()) {
791          std::list<Triangle*> listTriangle0=(*it0).second;        std::list<Triangle*> listTriangle0=(*it0).second;
792          std::list<Triangle*> listTriangle1=(*it1).second;        std::list<Triangle*> listTriangle1=(*it1).second;
793          for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ;        for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ;
794              jt0!=listTriangle0.end() ; ++jt0) {            jt0!=listTriangle0.end() ; ++jt0) {
795            for(std::list<Triangle*>::iterator jt1=listTriangle1.begin() ;          for(std::list<Triangle*>::iterator jt1=listTriangle1.begin() ;
796                jt1!=listTriangle1.end() ; ++jt1) {              jt1!=listTriangle1.end() ; ++jt1) {
797              __createPointIntersection(0,1,jt0,jt1);            __createPointIntersection(0,1,jt0,jt1);
           }  
798          }          }
       } else {  
         //ffout(0)<<"pas d'intersection dans l'hexa\n";  
799        }        }
800        } else {
801          //ffout(0)<<"pas d'intersection dans l'hexa\n";
802      }      }
803    }    }
804  }  }
# Line 830  void SurfaceMeshGenerator::Internals::__ Line 860  void SurfaceMeshGenerator::Internals::__
860    __addTriangle(*triangle[0],*triangle[1],*triangle[2],cell);    __addTriangle(*triangle[0],*triangle[1],*triangle[2],cell);
861  }  }
862    
863  void SurfaceMeshGenerator::Internals::plotini(size_t nobjectToTreat) {  // void SurfaceMeshGenerator::Internals::plotini(size_t nobjectToTreat) {
864    std::ofstream sortie2("ini.mesh");  //   std::ofstream sortie2("ini.mesh");
865    sortie2<<"MeshVersionFormatted 1"<<" \n";  //   sortie2<<"MeshVersionFormatted 1"<<" \n";
866    sortie2<<" \n";  //   sortie2<<" \n";
867    sortie2<<"Dimension"<<" \n";  //   sortie2<<"Dimension"<<" \n";
868    sortie2<<"3"<<" \n";  //   sortie2<<"3"<<" \n";
869    sortie2<<" \n";  //   sortie2<<" \n";
870    sortie2<<"Vertices"<<" \n";  //   sortie2<<"Vertices"<<" \n";
871    size_t nn=0,compt=0;  //   size_t nn=0,compt=0;
872    TinyVector<10,size_t> num;  //   TinyVector<10,size_t> num;
873    for(size_t numObj=0 ; numObj<nobjectToTreat ; ++numObj) {  //   for(size_t numObj=0 ; numObj<nobjectToTreat ; ++numObj) {
874      nn+=(*triangleListes [numObj]).size();  //     nn+=triangleListes.size();
875      if(compt<10) {  //     if(compt<10) {
876        num[compt]=nn;  //       num[compt]=nn;
877      }  //     }
878      ++compt;  //     ++compt;
879    }  //   }
880    sortie2<<3*nn<<"\n";  //   sortie2<<3*nn<<"\n";
881    
882    for(size_t numObj=0 ; numObj<nobjectToTreat ; ++numObj) {  //   for(size_t numObj=0 ; numObj<nobjectToTreat ; ++numObj) {
883      for (SurfaceMeshGenerator::Internals::EdgePairList::iterator  //     for (SurfaceMeshGenerator::Internals::EdgePairList::iterator
884             i = (*triangleListes[numObj]).begin();  //         i = triangleListes.begin();
885           i != (*triangleListes [numObj]).end(); ++i) {  //       i != triangleListes.end(); ++i) {
886        SurfaceMeshGenerator::Internals::VerticesList& V = (*verticesListes[numObj]);  //       SurfaceMeshGenerator::Internals::VerticesList& V = verticesListes;
887        const Vertex& V0=* V[(*i)[0]];  //       const Vertex& V0=* V[(*i)[0]];
888        const Vertex& V1=* V[(*i)[1]];  //       const Vertex& V1=* V[(*i)[1]];
889        const Vertex& V2=* V[(*i)[2]];  //       const Vertex& V2=* V[(*i)[2]];
890        sortie2<<V0.Vector3()[0]<<" "<<V0.Vector3()[1]<<" "<<V0.Vector3()[2]<<" 0 \n";  //       sortie2<<V0.Vector3()[0]<<" "<<V0.Vector3()[1]<<" "<<V0.Vector3()[2]<<" 0 \n";
891        sortie2<<V1.Vector3()[0]<<" "<<V1.Vector3()[1]<<" "<<V1.Vector3()[2]<<" 0 \n";  //       sortie2<<V1.Vector3()[0]<<" "<<V1.Vector3()[1]<<" "<<V1.Vector3()[2]<<" 0 \n";
892        sortie2<<V2.Vector3()[0]<<" "<<V2.Vector3()[1]<<" "<<V2.Vector3()[2]<<" 0 \n";  //       sortie2<<V2.Vector3()[0]<<" "<<V2.Vector3()[1]<<" "<<V2.Vector3()[2]<<" 0 \n";
893      }  //     }
894    }  //   }
895    sortie2<<" \n";  //   sortie2<<" \n";
896    sortie2<<"Triangles"<<"\n";  //   sortie2<<"Triangles"<<"\n";
897    sortie2<<nn<<"\n";  //   sortie2<<nn<<"\n";
898    
899    for(size_t nj=0;nj<nn;++nj) {  //   for(size_t nj=0;nj<nn;++nj) {
900      sortie2<<3*nj+1<<" "<<3*nj+2<<" "<<3*nj+3;  //     sortie2<<3*nj+1<<" "<<3*nj+2<<" "<<3*nj+3;
901      if(nj<num[0])  //     if(nj<num[0])
902        sortie2<<" 2 \n";  //       sortie2<<" 2 \n";
903      else if(nj<num[1])  //     else if(nj<num[1])
904        sortie2<<" 3 \n";  //       sortie2<<" 3 \n";
905      else if(nj<num[2])  //     else if(nj<num[2])
906        sortie2<<" 4 \n";  //       sortie2<<" 4 \n";
907      else if(nj<num[3])  //     else if(nj<num[3])
908        sortie2<<" 5 \n";  //       sortie2<<" 5 \n";
909      else if(nj<num[4])  //     else if(nj<num[4])
910        sortie2<<" 6 \n";  //       sortie2<<" 6 \n";
911      else  //     else
912        sortie2<<" 7 \n";  //       sortie2<<" 7 \n";
913    }  //   }
914    sortie2<<"End"<<" \n";  //   sortie2<<"End"<<" \n";
915  }  // }
916    
917  size_t SurfaceMeshGenerator::Internals::  size_t SurfaceMeshGenerator::Internals::
918  __IsInTriangle(const TinyVector<2,size_t> & num,const TinyVector<3,TinyVector<3> > & triangleVector )  __IsInTriangle(const TinyVector<2,size_t> & num,const TinyVector<3,TinyVector<3> > & triangleVector )
# Line 1147  __inout(const size_t& numobject, Line 1177  __inout(const size_t& numobject,
1177    size_t& refVertex1=(*edgesRefVertex[numobject])[V1];    size_t& refVertex1=(*edgesRefVertex[numobject])[V1];
1178    
1179    if(refVertex0+refVertex1==4 and edgeCut==1) {    if(refVertex0+refVertex1==4 and edgeCut==1) {
1180      ffout(0)<<"warning edge ref 2 cut \n";      ffout(1)<<"warning edge ref 2 cut \n";
1181      ffout(0)<<(*V0).Vector3()[0]<<" "<<(*V0).Vector3()[1]<<" "<<(*V0).Vector3()[2]<<" \n";      ffout(1)<<(*V0).Vector3()[0]<<" "<<(*V0).Vector3()[1]<<" "<<(*V0).Vector3()[2]<<" \n";
1182      ffout(0)<<(*V1).Vector3()[0]<<" "<<(*V1).Vector3()[1]<<" "<<(*V1).Vector3()[2]<<" \n";      ffout(1)<<(*V1).Vector3()[0]<<" "<<(*V1).Vector3()[1]<<" "<<(*V1).Vector3()[2]<<" \n";
1183      refVertex0=0;      refVertex0=0;
1184      refVertex1=0;      refVertex1=0;
1185    } else {    } else {
# Line 1369  __createCase1(int ncase, Line 1399  __createCase1(int ncase,
1399       // ffout(0)<<V0.Vector3()<<"\n";       // ffout(0)<<V0.Vector3()<<"\n";
1400       // ffout(0)<<V1.Vector3()<<"\n";       // ffout(0)<<V1.Vector3()<<"\n";
1401       // ffout(0)<<V2.Vector3()<<"\n";       // ffout(0)<<V2.Vector3()<<"\n";
1402        __createByEdges(K,cell);      __createByEdges(K,cell);
1403    }    }
1404    }    }
1405  }  }
# Line 2106  __createByEdges(const TriangleCut& K,con Line 2136  __createByEdges(const TriangleCut& K,con
2136  }  }
2137    
2138    
2139    template <typename booleanTest>
2140  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
2141  __createTrianglesIntersection(const size_t numobject,  __createTrianglesIntersection(const size_t numobject,
2142                                const ObjectToTreat& O1,                                const ObjectToTreat& O1,
# Line 2116  __createTrianglesIntersection(const size Line 2147  __createTrianglesIntersection(const size
2147    if(numobject==0)    if(numobject==0)
2148      objectNumber=1;      objectNumber=1;
2149    MapCellTriangle hexaToTriangle0=*(O1.hexalist);    MapCellTriangle hexaToTriangle0=*(O1.hexalist);
2150      
2151    //Initialize edgesRefVertex    std::set<const Cell*> hexaList1;
2152    size_t taille=0;    std::set<const Cell*> hexaListIn;
2153    const Vector<Triangle>& triangleList = (*O1.trianglelist);  
2154    for(size_t size=0 ; size<triangleList.size() ; ++size)  {    for (MapCellTriangle::const_iterator i=(*O1.hexalist).begin(); i!= (*O1.hexalist).end(); ++i) {
2155      const Triangle& T=triangleList[size];      hexaList1.insert((*i).first);
2156      if(!O1.inside(T(0)) and !O2.inside(T(0))) {    }
2157        (*edgesRefVertex[numobject])[&T(0)]=2;  
2158      } else {    std::set_difference (hexaList1.begin(), hexaList1.end(),
2159        (*edgesRefVertex[numobject])[&(T(0))]=0;                         toTreatHexahedra.begin(), toTreatHexahedra.end(),
2160                           inserter(hexaListIn, hexaListIn.begin()));
2161    
2162      for (std::set<const Cell*>::iterator icell = hexaListIn.begin(); icell != hexaListIn.end(); ++icell) {
2163        Cell& C = const_cast<Cell&>(*(*icell));
2164        for (size_t i=0; i<C.numberOfVertices(); ++i) {
2165          C(i).Ref() = ((*O1.shape()).inside(C(i))?1:0)
2166            + ((*O2.shape()).inside(C(i))?1:0);
2167      }      }
2168      if(!O1.inside(T(1)) and !O2.inside(T(1))) {  
2169        (*edgesRefVertex[numobject])[&T(1)]=2;      size_t ref;
2170        if (booleanTest::compute(C)) {
2171          ref=2;
2172      } else {      } else {
2173        (*edgesRefVertex[numobject])[&(T(1))]=0;        ref=0;
2174      }      }
2175      if(!O1.inside(T(2)) and !O2.inside(T(2))) {  
2176        (*edgesRefVertex[numobject])[&T(2)]=2;      MapCellTriangle::iterator it0=hexaToTriangle0.find(*icell);
2177      } else {  
2178        (*edgesRefVertex[numobject])[&(T(2))]=0;      if(it0!=hexaToTriangle0.end()) {
2179      }        std::list<Triangle*> listTriangle0=(*it0).second;
2180      if((*edgesRefVertex[numobject])[&T(0)]==2  
2181          and (*edgesRefVertex[numobject])[&T(1)]==2        for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ;
2182          and (*edgesRefVertex[numobject])[&T(2)]==2) {            jt0!=listTriangle0.end() ; ++jt0) {
2183         __addTriangle(T(0),T(1),T(2),&T.mother());  
2184       }          Triangle& T = (*(*jt0));
2185            for (size_t n=0; n<3; ++n) {
2186              (*edgesRefVertex[numobject])[&T(n)]=ref;
2187            }
2188    
2189            if((*edgesRefVertex[numobject])[&T(0)]==2
2190               and (*edgesRefVertex[numobject])[&T(1)]==2
2191               and (*edgesRefVertex[numobject])[&T(2)]==2) {
2192              __addTriangle(T(0),T(1),T(2),&T.mother());
2193            }
2194          }
2195        }
2196    }    }
2197        
2198    size_t nbinters=listVertexIntersectionNew.size();    size_t nbinters=listVertexIntersectionNew.size();
# Line 2370  __createTrianglesIntersection(const size Line 2421  __createTrianglesIntersection(const size
2421      }      }
2422    }    }
2423    
   if(err==taille) {  
     ffout(0)<<"tous les triangles de la liste d'intersection sont dehors\n";  
   }  
   
   if(err2==taille) {  
     ffout(0)<<"aucun triangle de la liste d'intersection n'est coupe\n";  
   }  
   
2424    (*edgesRefVertex[numobject]).clear();    (*edgesRefVertex[numobject]).clear();
2425  }  }
2426    
2427  bool SurfaceMeshGenerator::Internals::  bool SurfaceMeshGenerator::Internals::
2428  __createTriangleSurface(const size_t& nobject,  __createTriangleSurface(VerticesList& verticesListes,
2429                            EdgePairList& localTriangleList,
2430                            EdgesRef& edgesRef,
2431                          const Shape& S ,                          const Shape& S ,
2432                          std::vector<const Edge*>& cutEdges,                          std::vector<const Edge*>& cutEdges,
2433                          const Reference::Representation& ref,                          const Cell& currentCell)
2434                          const Cell& currentCell){  {
2435    bool jobDone=true;    bool jobDone=true;
2436    switch (cutEdges.size()) {    switch (cutEdges.size()) {
2437    case 3: {    case 3: {
2438      //! Stores the Edges on which the vertex will be computed.      //! Stores the Edges on which the vertex will be computed.
2439                            
2440      for (size_t i=0; i<cutEdges.size(); ++i) {      for (size_t i=0; i<cutEdges.size(); ++i) {
2441        TinyVector<3> V=__splitEdge(*cutEdges[i], ref, S);        TinyVector<3> V=__splitEdge(*cutEdges[i], S);
2442        (*verticesListes[nobject])[*cutEdges[i]]        verticesListes[*cutEdges[i]]
2443          =  new Vertex(V);          =  new Vertex(V);
2444        (*edgesRef[nobject])[*cutEdges[i]] = 1;        edgesRef[*cutEdges[i]] = 1;
2445      }      }
2446            
2447      //! Addes a triangle to the list.      //! Addes a triangle to the list.
# Line 2406  __createTriangleSurface(const size_t& no Line 2451  __createTriangleSurface(const size_t& no
2451      std::vector<TinyVector<3> > V(cutEdges.size());      std::vector<TinyVector<3> > V(cutEdges.size());
2452      for(size_t i=0; i<cutEdges.size(); ++i) {      for(size_t i=0; i<cutEdges.size(); ++i) {
2453        const Edge& e = *cutEdges[i];        const Edge& e = *cutEdges[i];
2454        if(e(0).Ref().isSet(ref)) {        if(e(0).Ref() == 1) {
2455          V[i] = (e(0).Vector3() - e(1).Vector3());          V[i] = (e(0).Vector3() - e(1).Vector3());
2456        } else {        } else {
2457          V[i] = (e(1).Vector3() - e(0).Vector3());          V[i] = (e(1).Vector3() - e(0).Vector3());
# Line 2430  __createTriangleSurface(const size_t& no Line 2475  __createTriangleSurface(const size_t& no
2475    
2476    case 4: {    case 4: {
2477      for (size_t i=0; i<4; ++i) {      for (size_t i=0; i<4; ++i) {
2478        TinyVector<3> V=__splitEdge(*cutEdges[i], ref, S);        TinyVector<3> V=__splitEdge(*cutEdges[i], S);
2479        (*verticesListes[nobject])[*cutEdges[i]]        verticesListes[*cutEdges[i]]
2480          =  new Vertex(V);          =  new Vertex(V);
2481        (*edgesRef[nobject])[*cutEdges[i]] = 1;        edgesRef[*cutEdges[i]] = 1;
2482      }      }
2483            
2484      //! Orders the Edges using a map !      //! Orders the Edges using a map !
# Line 2450  __createTriangleSurface(const size_t& no Line 2495  __createTriangleSurface(const size_t& no
2495      std::map<Edge::Pair, const Edge*>::iterator currentCutEdge=cutEdgesMap.begin();      std::map<Edge::Pair, const Edge*>::iterator currentCutEdge=cutEdgesMap.begin();
2496      for (size_t i=0; i<V.size(); ++i) {      for (size_t i=0; i<V.size(); ++i) {
2497        const Edge& e = *(*currentCutEdge).second;        const Edge& e = *(*currentCutEdge).second;
2498        if(e(0).Ref().isSet(ref)) {        if(e(0).Ref() == 1) {
2499          V[i] = (e(0).Vector3() - e(1).Vector3());          V[i] = (e(0).Vector3() - e(1).Vector3());
2500        } else {        } else {
2501          V[i] = (e(1).Vector3() - e(0).Vector3());          V[i] = (e(1).Vector3() - e(0).Vector3());
# Line 2510  __createTriangleSurface(const size_t& no Line 2555  __createTriangleSurface(const size_t& no
2555    
2556  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
2557  __createSurface(Structured3DMesh& SMesh,  __createSurface(Structured3DMesh& SMesh,
2558                  const Shape& S ,                  const Shape& S,
2559                  const Reference::Representation& ref,                  EdgePairList& triangleListes,
2560                  size_t nobject) {                  EdgePairList& localTriangleListesEdges,
2561                    VerticesList& verticesListes,
2562                    EdgesRef& edgesRef,
2563                    MotherCellList& cellListObject)
2564    {
2565      EdgePairList localTriangleList;
2566    
2567    for (size_t i = 0; i<SMesh.nbEdges(); i++) {    for (size_t i = 0; i<SMesh.nbEdges(); i++) {
2568      Edge& e = SMesh.edge(i);      Edge& e = SMesh.edge(i);
2569  #warning THIS TEST IS NOT ENOUGH! THINK TO THE BORDER!  #warning THIS TEST IS NOT ENOUGH! THINK TO THE BORDER!
2570      if(/*(e(0).Ref().insideDomain() xor e(1).Ref().insideDomain())      if(e(0).Ref() != e(1).Ref()) {
2571           and*/((e(0).Ref().isSet(ref)) xor (e(1).Ref().isSet(ref)))) {        verticesListes[e] = new Vertex(__splitEdge(e, S));
2572        (*verticesListes[nobject])[e] = new Vertex(__splitEdge(e, ref, S));        edgesRef[e] = 1;
       (*edgesRef[nobject])[e] = 1;  
2573      }      }
2574    }    }
2575            
2576    if ((*verticesListes[nobject]).size()==0) {    if (verticesListes.size()==0) {
2577    
2578      fferr(2) << __FILE__ << ':' << __LINE__ << ": "      fferr(2) << __FILE__ << ':' << __LINE__ << ": "
2579               << "meshing object " << S << " a problem occured ...\n"               << "meshing object " << S << " a problem occured ...\n"
# Line 2572  __createSurface(Structured3DMesh& SMesh, Line 2621  __createSurface(Structured3DMesh& SMesh,
2621    
2622          for (size_t l=0; l<H.numberOfEdges(); l++) {          for (size_t l=0; l<H.numberOfEdges(); l++) {
2623            Edge& e = H.edge(l);            Edge& e = H.edge(l);
2624            if ((*verticesListes[nobject]).count(e) > 0) {            if (verticesListes.count(e) > 0) {
2625              intersected = true;              intersected = true;
2626              break;              break;
2627            }            }
# Line 2614  __createSurface(Structured3DMesh& SMesh, Line 2663  __createSurface(Structured3DMesh& SMesh,
2663                  *(currentAddedEdge) = Edge(currentCell(TverticesList[i1]),                  *(currentAddedEdge) = Edge(currentCell(TverticesList[i1]),
2664                                             currentCell(TverticesList[i2+1]));                                             currentCell(TverticesList[i2+1]));
2665                  Edge& e = (*currentAddedEdge);                  Edge& e = (*currentAddedEdge);
2666                  if (((e(0).Ref().isSet(ref)) xor (e(1).Ref().isSet(ref)))                  if (e(0).Ref() != e(1).Ref()) {
                     /*and (e(0).Ref().insideDomain() xor e(1).Ref().insideDomain())*/) {  
2667                    e.Ref() = 1;                    e.Ref() = 1;
2668                    (*edgesRef[nobject])[e] = 1;                    edgesRef[e] = 1;
2669                  }                  }
2670                  currentAddedEdge++;                  currentAddedEdge++;
2671                }                }
# Line 2707  __createSurface(Structured3DMesh& SMesh, Line 2755  __createSurface(Structured3DMesh& SMesh,
2755                            
2756              for(size_t ie=0; ie<6; ++ie) {              for(size_t ie=0; ie<6; ++ie) {
2757                const Edge& e = currentT->edge(ie);                const Edge& e = currentT->edge(ie);
2758                if ((*edgesRef[nobject]).find(e) != (*edgesRef[nobject]).end()) {                if (edgesRef.find(e) != edgesRef.end()) {
2759                  cutEdges.push_back(&e);                  cutEdges.push_back(&e);
2760                }                }
2761              }              }
2762                            
2763              bool jobDone2=__createTriangleSurface(nobject,S,cutEdges,              bool jobDone2=__createTriangleSurface(verticesListes,
2764                                       ref,currentCell);                                                    localTriangleList,
2765                                                      edgesRef,
2766                                                      S, cutEdges,
2767                                                      currentCell);
2768              if(!(jobDone2)) {              if(!(jobDone2)) {
2769                  jobDone=jobDone2;                  jobDone=jobDone2;
2770              }              }
# Line 2725  __createSurface(Structured3DMesh& SMesh, Line 2776  __createSurface(Structured3DMesh& SMesh,
2776              for (SurfaceMeshGenerator::Internals::EdgePairList::iterator t              for (SurfaceMeshGenerator::Internals::EdgePairList::iterator t
2777                     = localTriangleList.begin();                     = localTriangleList.begin();
2778                   t != localTriangleList.end(); ++t) {                   t != localTriangleList.end(); ++t) {
2779                (*triangleListes[nobject]).push_front(*t);                triangleListes.push_front(*t);
2780                (*cellListObject[nobject]).push_front(*itcell);                cellListObject.push_front(*itcell);
2781                ++itcell;                ++itcell;
2782              }              }
2783              hexaTetraAssociation[&currentCell]              hexaTetraAssociation[&currentCell]
# Line 2743  __createSurface(Structured3DMesh& SMesh, Line 2794  __createSurface(Structured3DMesh& SMesh,
2794                =cellList.begin();                =cellList.begin();
2795              for (EdgePairList::iterator t = localTriangleList.begin();              for (EdgePairList::iterator t = localTriangleList.begin();
2796                   t != localTriangleList.end(); ++t) {                   t != localTriangleList.end(); ++t) {
2797                (*triangleListes[nobject]).push_front(*t);                triangleListes.push_front(*t);
2798                (*cellListObject[nobject]).push_front(*itcell);                cellListObject.push_front(*itcell);
2799                ++itcell;                ++itcell;
2800              }              }
2801            }            }
# Line 2794  generatesAllSufaceMeshes(const Problem& Line 2845  generatesAllSufaceMeshes(const Problem&
2845      }      }
2846    }    }
2847    
   dynamic_cast<Structured3DMesh&>(M).createReferences(Omega);  
   
2848    const Scene& scene =Omega.scene();    const Scene& scene =Omega.scene();
2849    
   std::set<Reference::Representation> referencesList;  
   for(POVRayReferences::iterator povRef = povRefList.begin();  
       povRef!= povRefList.end(); ++povRef) {  
     Reference::Representation ref;  
     ref.resize(scene.nbObjects());  
     for (size_t i=0; i<scene.nbObjects(); ++i) {  
       const Object& O = scene.object(i);  
       if (O.reference() == povRef->first) {  
         dynamic_cast<Structured3DMesh&>(M).createReferences(Omega,O.reference());  
       }  
     }  
     referencesList.insert(ref);  
   }  
   
2850    for(POVRayReferences::iterator povRef = povRefList.begin();    for(POVRayReferences::iterator povRef = povRefList.begin();
2851        povRef!= povRefList.end(); ++povRef) {        povRef!= povRefList.end(); ++povRef) {
2852      for (size_t i=0; i<scene.nbObjects(); ++i) {      for (size_t i=0; i<scene.nbObjects(); ++i) {
# Line 2829  generatesAllSufaceMeshes(const Problem& Line 2864  generatesAllSufaceMeshes(const Problem&
2864          this->generateSurfacicMesh(O,          this->generateSurfacicMesh(O,
2865                                     Omega,                                     Omega,
2866                                     *surfMesh,                                     *surfMesh,
2867                                     dynamic_cast<Structured3DMesh&>(M),                                     dynamic_cast<Structured3DMesh&>(M));
                                    ref,  
                                    referencesList);  
2868    
2869          vrRefMesh[povRef->first].push_back(surfMesh);          vrRefMesh[povRef->first].push_back(surfMesh);
2870        }        }
# Line 2983  void plotmedit(const size_t& nobject, Line 3016  void plotmedit(const size_t& nobject,
3016  void plothexa(size_t ncase,std::set<const Cell*>& cuttedHexahedra);  void plothexa(size_t ncase,std::set<const Cell*>& cuttedHexahedra);
3017    
3018    
3019  void showObject(const Object& object, const size_t& level,  void SurfaceMeshGenerator::Internals::
3020                  std::stack<std::string>& objectStack)  __showObject(Structured3DMesh& SMesh,
3021                 const Object& object, const size_t& level,
3022                 std::stack<ReferenceCounting<ObjectToTreat> >& objectStack)
3023  {  {
3024    for (size_t i=0; i<level; ++i)    for (size_t i=0; i<level; ++i)
3025      std::cout << "==";      std::cout << "==";
3026    switch(object.shapeType()) {    switch(object.shapeType()) {
3027    case Shape::union_: {    case Shape::union_: {
3028      const Union& U = static_cast<const Union&>(*(object.shape()));      const Union& U = static_cast<const Union&>(*(object.shape()));
3029      std::cout << "Union:\n";  
3030      size_t j=0;      size_t j=0;
3031      for(Union::const_iterator i = U.begin();      for(Union::const_iterator i = U.begin();
3032          i != U.end(); ++i, ++j) {          i != U.end(); ++i,++j) {
3033        showObject((*(*i)), level+1, objectStack);        __showObject(SMesh,(*(*i)), level+1, objectStack);
3034        if (j>0) {        if (j>0) {
3035          for (size_t l=0; l<level; ++l)          for (size_t l=0; l<level; ++l)
3036            std::cout << "==";            std::cout << "==";
3037    
3038          std::string u = "union(";          std::cerr << "Calcule l'union\n";
3039          std::cerr << "Calcule l'union de " << objectStack.top();  
3040          u+=objectStack.top();          // get first object of the intersection
3041            ReferenceCounting<ObjectToTreat> O1 = objectStack.top();
3042          objectStack.pop();          objectStack.pop();
3043          u+=" et de ";  
3044          std::cerr << " et de " << objectStack.top() << '\n';          // get second object of the intersection
3045          u+=objectStack.top();          ReferenceCounting<ObjectToTreat> O2 = objectStack.top();
3046          objectStack.pop();          objectStack.pop();
3047    
3048          u+=")";          ReferenceCounting<ObjectToTreat> O0 = new ObjectToTreat();
3049          objectStack.push(u);          __operationBoolean<UnionTest>(*O0,*O1, *O2);
3050    
3051            // Set shape function
3052            Union* u = new Union();
3053            u->push_back(new Object((*O1).shape(), TinyVector<3,real_t>(0,0,0)));
3054            u->push_back(new Object((*O2).shape(), TinyVector<3,real_t>(0,0,0)));
3055            (*O0).setShape(u);
3056    
3057            objectStack.push(O0);
3058    
3059            std::cerr << __LINE__ << " Push union object!\n";
3060        }        }
3061      }      }
3062      break;      break;
3063    }  case Shape::intersection: {    }
3064      case Shape::intersection: {
3065      const Intersection& I = static_cast<const Intersection&>(*(object.shape()));      const Intersection& I = static_cast<const Intersection&>(*(object.shape()));
3066      std::cout << "Intersection:\n";  
3067      size_t j=0;      size_t j=0;
3068      for(Intersection::const_iterator i = I.begin();      for(Intersection::const_iterator i = I.begin();
3069          i != I.end(); ++i,++j) {          i != I.end(); ++i,++j) {
3070        showObject((*(*i)), level+1, objectStack);        __showObject(SMesh,(*(*i)), level+1, objectStack);
3071        if (j>0) {        if (j>0) {
3072          for (size_t l=0; l<level; ++l)          for (size_t l=0; l<level; ++l)
3073            std::cout << "==";            std::cout << "==";
3074    
3075          std::string u = "intersection(";          std::cerr << "Calcule l'intersection\n";
3076          std::cerr << "Calcule l'intersection de " << objectStack.top();  
3077          u+=objectStack.top();          // get first object of the intersection
3078            ReferenceCounting<ObjectToTreat> O1 = objectStack.top();
3079          objectStack.pop();          objectStack.pop();
3080          u+=" et de ";  
3081          std::cerr << " et de " << objectStack.top() << '\n';          // get second object of the intersection
3082          u+=objectStack.top();          ReferenceCounting<ObjectToTreat> O2 = objectStack.top();
3083          objectStack.pop();          objectStack.pop();
3084    
3085          u+=")";          ReferenceCounting<ObjectToTreat> O0 = new ObjectToTreat();
3086          objectStack.push(u);          __operationBoolean<IntersectionTest>(*O0,*O1, *O2);
3087    
3088            // Set shape function
3089            Intersection* newI = new Intersection();
3090            newI->push_back(new Object((*O1).shape(), TinyVector<3,real_t>(0,0,0)));
3091            newI->push_back(new Object((*O2).shape(), TinyVector<3,real_t>(0,0,0)));
3092            (*O0).setShape(newI);
3093    
3094            objectStack.push(O0);
3095    
3096            std::cerr << __LINE__ << " Push union object!\n";
3097        }        }
3098      }      }
3099      break;      break;
3100    } case Shape::difference: {    }
3101      case Shape::difference: {
3102    
3103      fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n";      fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n";
3104        std::exit(1);
3105    
3106      break;      break;
3107    } case Shape::not_: {    }
3108      const Not& N = static_cast<const Not&>(*(object.shape()));    case Shape::not_: {
3109      std::cout << "Not:\n";      const Object& notObject = *(static_cast<const Not&>(*object.shape()).object());
3110      showObject((*N.object()), level+1, objectStack);      __showObject(SMesh, notObject,
3111                     level+1, objectStack);
3112    
3113        ObjectToTreat& o = (*objectStack.top());
3114        ReferenceCounting<Shape> s = o.shape();
3115    #warning NE PAS APPELER 'new Object'
3116        o.setShape(new Not(new Object(s, TinyVector<3,real_t>(0,0,0))));
3117    
3118      break;      break;
3119    } default: {    }
3120      objectStack.push((*object.shape()).typeName());    default: {
3121        ReferenceCounting<ObjectToTreat> o = new ObjectToTreat();
3122        (*o).setShape(object.shape());
3123        __marchingTetrahedra(SMesh, *o,
3124                             0);
3125    
3126        objectStack.push(o);
3127      std::cout << "Marching cube sur " << objectStack.top() << '\n';      std::cout << "Marching cube sur " << objectStack.top() << '\n';
3128    }    }
3129    }    }
3130  }  }
3131    
3132    ReferenceCounting<Vector<Triangle> >
3133    SurfaceMeshGenerator::Internals::
3134    __marchingTetrahedra(Structured3DMesh& SMesh,
3135                         ObjectToTreat& O,
3136                         //                        const Shape& S,
3137                         //                        const Reference::Representation& ref,
3138                         size_t nobject)
3139    {
3140      EdgePairList triangleListes;
3141      EdgePairList localTriangleListesEdges;
3142      VerticesList verticesListes;
3143      EdgesRef edgesRef;
3144      MotherCellList cellListObject;
3145    
3146      SMesh.createReferences(*(O.shape()));
3147    
3148      __createSurface(SMesh, *(O.shape()), triangleListes, localTriangleListesEdges,
3149                      verticesListes, edgesRef, cellListObject);
3150    
3151      __dataStructureConvertion(O, triangleListes, verticesListes, cellListObject);
3152      return 0;
3153    }
3154    
3155  /*! Generates a surfacic mesh using only characteristic function of an object  /*! Generates a surfacic mesh using only characteristic function of an object
3156    and the Structured 3D Mesh.    and the Structured 3D Mesh.
3157    
# Line 3063  void SurfaceMeshGenerator:: Line 3161  void SurfaceMeshGenerator::
3161  generateSurfacicMesh(const Object& O,  generateSurfacicMesh(const Object& O,
3162                       const Domain& Omega,                       const Domain& Omega,
3163                       SurfaceMeshOfTriangles& s_mesh,                       SurfaceMeshOfTriangles& s_mesh,
3164                       Structured3DMesh& SMesh,                       Structured3DMesh& SMesh)
3165                       const Reference::Representation& ref,  {
                      const std::set<Reference::Representation>& referencesList)  
  {  
3166    const Shape& S = *(O.shape());    const Shape& S = *(O.shape());
3167            
3168    typedef std::map<TinyVector<3>, Object*,    typedef std::map<TinyVector<3>, Object*,
3169      SurfaceMeshGenerator::Internals::__ltv> ObjectReferences;      SurfaceMeshGenerator::Internals::__ltv> ObjectReferences;
3170    
   ObjectReferences otherReferences;  
   
3171    const Object& object = Omega.object();    const Object& object = Omega.object();
3172    const Scene& scene = Omega.scene();    const Scene& scene = Omega.scene();
3173    
3174    std::stack<std::string> objectStack;    (*__internals).edgesRefVertex.resize(scene.nbObjects());
   showObject(object, 0, objectStack);  
3175    
3176    switch (object.shapeType()) {    for(size_t no=0 ; no<scene.nbObjects() ; ++no) {
   case Shape::union_: {  
     const Union& U = static_cast<const Union&>(*(object.shape()));  
     for(Union::const_iterator i = U.begin();  
         i != U.end(); ++i) {  
       otherReferences[(*(*i)).reference()] = *i;  
     }  
     break;  
   }  case Shape::intersection: {  
     const Intersection& I = static_cast<const Intersection&>(*(object.shape()));  
     Internals::__getIntersectionReferences(I, otherReferences);  
     break;  
   } case Shape::difference: {  
     fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n";  
     break;  
   } case Shape::not_: {  
     //  fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n";  
     break;  
   } default: {  
     //std::exit(1);  
   }  
   }      
   
   //  for(ObjectReferences::iterator i=otherReferences.begin();i!=otherReferences.end();++i)  
   //    ffout(0) << (*i).first <<"\n";  
   
   size_t nobject = scene.nbObjects();  
   size_t nobjectToTreat = otherReferences.size();  
   ffout(0)<<"size other ref "<<nobjectToTreat<<"\n";  
   
   (*__internals).verticesListes.resize(nobject);  
   (*__internals).triangleListes.resize(nobject);  
   (*__internals).localTriangleListesEdges.resize(nobject);  
   (*__internals).edgesRef.resize(nobject);  
   (*__internals).cellListObject.resize(nobject);  
   (*__internals).edgesRefVertex.resize(nobject);  
   
   for(size_t no=0 ; no<nobject ; ++no) {  
     (*__internals).triangleListes[no]= new SurfaceMeshGenerator::Internals::EdgePairList;  
     (*__internals).localTriangleListesEdges[no]= new SurfaceMeshGenerator::Internals::EdgePairList;  
     (*__internals).verticesListes[no]= new SurfaceMeshGenerator::Internals::VerticesList;  
     (*__internals).cellListObject[no]= new SurfaceMeshGenerator::Internals::MotherCellList;  
   
     (*__internals).edgesRef[no]= new std::map<Edge::Pair, size_t> ;  
3177      (*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ;      (*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ;
3178    }    }
3179    
3180      std::stack<ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat> > objectStack;
3181      (*__internals).__showObject(SMesh,object, 0, objectStack);
3182    
   //Marching Cube for each object  
   int num=0;  
   if(nobjectToTreat<2) {  
     (*__internals).__createSurface(SMesh,S,ref,num);  
   } else {  
    /* for(ObjectReferences::iterator i = otherReferences.begin();  
         i != otherReferences.end(); ++i) {  
       for(size_t n = 0; n<scene.nbObjects(); ++n) {  
         Reference::Representation otherRef;  
         otherRef.resize(scene.nbObjects());  
         //ffout(0) << scene.object(n).reference() << ":"<< ((*i).first) << '\n';  
         if (scene.object(n).reference() == ((*i).first)) {  
           otherRef[n] = true;  
           //create surface objects  
           ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat > pObject  
           = new SurfaceMeshGenerator::Internals::ObjectToTreat(scene.object(n));  
           (*__internals).listOfObjectToTreat.push_back(pObject);              
           (*__internals).__createSurface(SMesh,  
                                          *(scene.object(n).shape()),otherRef,num);  
         }  
       }  
       plothexa(num,cuttedHexahedra);  
       if(num==0) {  
         plothexa(num-1,cuttedHexahedra);  
       }  
       num++;  
     }*/  
   }  
   
   //construction list of Hexahedra  
   //std::set_difference (cuttedHexahedra.begin(), cuttedHexahedra.end(),  
   //                   meshedHexahedra.begin(), meshedHexahedra.end(),  
   //                   inserter((*__internals).toTreatHexahedra, (*__internals).toTreatHexahedra.begin()));  
   
       
   //  (*__internals).toTreatHexahedra=meshedHexahedra;  
  /* std::set<const Cell*>::iterator iterat=(*__internals).toTreatHexahedra.begin();  
   size_t treatsize=(*__internals).toTreatHexahedra.size();  
   for(size_t yy=0 ; yy<treatsize ; ++yy)  
     {  
       SurfaceMeshGenerator::Internals::HexaTetraAssociation::iterator  
         j=(*__internals).hexaTetraAssociation.find(*iterat);  
       std::vector<TetrahedronByEdges>& T = *(((*j).second).first);  
       const CartesianHexahedron& currentCell  
         = static_cast<const CartesianHexahedron&>(*(*iterat));  
       // ffout(0)<<"*********************************\n";  
       size_t test=0;  
       std::set<const Cell*>::iterator temp=iterat++;  
       for (std::vector<TetrahedronByEdges>::iterator currentT = T.begin();  
            currentT < T.end(); ++currentT) {  
           
         std::vector<ReferenceCounting< std::vector<const Edge*> > > cutEdges;  
         cutEdges.resize(nobject);  
         for(size_t no=0 ; no<nobject ; ++no) {  
           cutEdges[no]= new std::vector<const Edge*>;  
         }  
         (*__internals).__createCutEdges(scene,cutEdges,otherReferences,currentT);  
         for(size_t no=0 ; no<nobject ; ++no) {  
           if((*cutEdges[no]).size()>0) {  
             test++;  
           }  
         }  
         if(test<2)  
           test=0;  
         else  
           test=2;  
       }  
       if(test!=2) {  
         (*__internals).toTreatHexahedra.erase(temp);  
       }  
     }*/  
   //ffout(0)<<"nb tr objet 0 complet "<<(*(*__internals).triangleListes[0]).size()<<" \n";  
     
   (*__internals).plotini(nobjectToTreat);  
       
   size_t nb=nobjectToTreat;  
   if(nb==0) {  
     nb=1;  
         
     ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat > pObject  
       = new SurfaceMeshGenerator::Internals::ObjectToTreat(scene.object(0));  
     (*__internals).listOfObjectToTreat.push_back(pObject);  
     (*__internals).__dataStructureConvertion(0);  
   }  
   
   num=0;  
   ObjectReferences::iterator ibegin = otherReferences.begin();  
     
   if(nobjectToTreat>1) {  
       
     for(size_t n = 0; n<scene.nbObjects(); ++n) {  
       Reference::Representation otherRef;  
       otherRef.resize(scene.nbObjects());  
       if (scene.object(n).reference() == ((*ibegin).first)) {  
         otherRef[n] = true;  
         //create surface objects  
         ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat > pObject  
           = new SurfaceMeshGenerator::Internals::ObjectToTreat(scene.object(n));  
         (*__internals).listOfObjectToTreat.push_back(pObject);  
         (*__internals).__createSurface(SMesh,  
                                 *(scene.object(n).shape()),otherRef,num);  
       }  
     }  
     (*__internals).__dataStructureConvertion(num);  
     ++num;  
     ibegin++;  
   }  
   (*__internals).listOfObjectToTreat2.push_back((*__internals).listOfObjectToTreat[0]);  
   
  // SurfaceMeshGenerator::Internals::ObjectToTreat O0=(*(*__internals).listOfObjectToTreat[0]);  
     
   size_t n0=0,n1=0;  
   if(nobjectToTreat>1) {  
     for(ObjectReferences::iterator i = ibegin;  
         i != otherReferences.end(); ++i) {  
       ffout(0)<<"treat object "<<num<<"\n"<<std::flush;  
       for(size_t n = 0; n<scene.nbObjects(); ++n) {  
         if (scene.object(n).reference() == ((*i).first)) {  
           ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat > pObject  
             = new SurfaceMeshGenerator::Internals::ObjectToTreat(scene.object(n));  
           (*__internals).listOfObjectToTreat.push_back(pObject);  
             
         }  
       }  
       SurfaceMeshGenerator::Internals::ObjectToTreat& O1=(*(*__internals).listOfObjectToTreat2[num-1]);  
       SurfaceMeshGenerator::Internals::ObjectToTreat& O2=(*(*__internals).listOfObjectToTreat[num]);  
   
       Union I;  
       I.push_back(&O1);  
       I.push_back(&O2);  
       Object OO(new Union(I),O1.reference());  
       ReferenceCounting<SurfaceMeshGenerator::Internals::ObjectToTreat > pObject  
           = new SurfaceMeshGenerator::Internals::ObjectToTreat(OO);  
       (*__internals).listOfObjectToTreat2.push_back(pObject);  
       SurfaceMeshGenerator::Internals::ObjectToTreat& O0=(*(*__internals).listOfObjectToTreat2[num]);  
   
       (*__internals).__operationBoolean(O0,num,O1,O2,Omega,SMesh);  
         
       num++;  
     }  
   }  
   //end intersection mesh  
   
   if(num==0)  
       num=1;  
   SurfaceMeshGenerator::Internals::ObjectToTreat& O0=(*(*__internals).listOfObjectToTreat2[num-1]);  
   //construction of list vertices  
   (*__internals).__constructionVerticesList(O0);  
     
3183    //construction of s_mesh    //construction of s_mesh
3184    (*__internals).__constructionFinalMesh(O0,s_mesh);    (*__internals).__constructionFinalMesh((*objectStack.top()),
3185                                             s_mesh);
3186    
3187      int n0=0, n1=0;
3188    //  plot2(s_mesh, (*__internals).toTreatHexahedra, SMesh);    //  plot2(s_mesh, (*__internals).toTreatHexahedra, SMesh);
3189    plotmedit(nobject,s_mesh, (*__internals).toTreatHexahedra,n0,n1);    plotmedit(scene.nbObjects(),s_mesh, (*__internals).toTreatHexahedra,n0,n1);
3190    
3191  }  }
3192    
3193  SurfaceMeshGenerator::SurfaceMeshGenerator()  SurfaceMeshGenerator::SurfaceMeshGenerator()
# Line 3397  void plotmedit(const size_t& nobject, Line 3303  void plotmedit(const size_t& nobject,
3303  }  }
3304    
3305    
 #warning REMOVE THIS  
 void SurfaceMeshGenerator::Internals::__getIntersectionReferences(const Intersection& I,  
                                                                   std::map<TinyVector<3>, Object*, SurfaceMeshGenerator::Internals::__ltv>& otherReferences)  
 {  
   for(Intersection::const_iterator i = I.begin();  
       i != I.end(); ++i) {  
     if ((*(*i)).shapeType() == Shape::intersection) {  
       const Intersection& I2 = static_cast<const Intersection&>(*(*(*i)).shape());  
       SurfaceMeshGenerator::Internals::__getIntersectionReferences(I2, otherReferences);  
     } else {  
       otherReferences[(*(*i)).reference()] = *i;  
       ffout(0) << (*(*i)).reference() << "\n";  
     }  
   }  
 }  
   
3306  // #include <vtkPolyDataMapper.h>  // #include <vtkPolyDataMapper.h>
3307  // #include <vtkRenderWindow.h>  // #include <vtkRenderWindow.h>
3308  // #include <vtkRenderWindowInteractor.h>  // #include <vtkRenderWindowInteractor.h>

Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25

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