/[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.17 by delpinux, Mon Jul 14 17:39:12 2003 UTC revision 1.18 by dobj, Tue Jul 15 15:49:11 2003 UTC
# Line 181  private: Line 181  private:
181                              const Reference::Representation& ref,                              const Reference::Representation& ref,
182                              const Shape& S);                              const Shape& S);
183    
184      void __dataStructureConvertion(const size_t nb);
185    
186      void __eraseAddTriangle(size_t& n0,size_t& n1);
187      
188    void __createListIntersection(const Shape& S,    void __createListIntersection(const Shape& S,
189                                  std::vector<const Edge*>& cutEdges,                                  std::vector<const Edge*>& cutEdges,
190                                  const Reference::Representation& ref,                                  const Reference::Representation& ref,
# Line 197  private: Line 201  private:
201    
202    void __calculatePointsIntersection(const Scene& scene,    void __calculatePointsIntersection(const Scene& scene,
203                                       size_t no,                                       size_t no,
204                                       size_t no2);                                       size_t number1);
205    
206    void __setBoundaryType(const Boundary& B,    void __setBoundaryType(const Boundary& B,
207                           POVRayReferences& vrRefList,                           POVRayReferences& vrRefList,
# Line 345  public : Line 349  public :
349                const Vertex& v2,                const Vertex& v2,
350                size_t num,                size_t num,
351                size_t num2)                size_t num2)
352          : Triangle(v0,v1,v2)
353    {    {
     __vertices[0] = (Vertex*)&v0;  
     __vertices[1] = (Vertex*)&v1;  
     __vertices[2] = (Vertex*)&v2;  
354      numobject=num;      numobject=num;
355      otherobject=num2;      otherobject=num2;
356      edgecut=0;      edgecut=0;
# Line 589  __createCutEdges(const Scene& scene, Line 591  __createCutEdges(const Scene& scene,
591    }    }
592  }  }
593    
594    void SurfaceMeshGenerator::Internals::__eraseAddTriangle(size_t& n0,size_t& n1)
595    {
596      SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator
597        it=listOfTriangleListIntersection.begin();
598      SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator
599        er=listOfTriangleListIntersection.erase(it);
600      it=listOfTriangleListIntersection.begin();
601      er=listOfTriangleListIntersection.erase(it);
602      
603      size_t sizeinter=triangleListIntersectionNew.size();
604      ReferenceCounting<Vector<Triangle> > pTriangleListIntersection = new Vector<Triangle>(sizeinter);
605      listOfTriangleListIntersection.push_front(pTriangleListIntersection);
606      Vector<Triangle>& triangleListIntersection = *pTriangleListIntersection;
607      
608      SurfaceMeshGenerator::Internals::ListOfHexaToTriangle::iterator
609        ithexa=listOfHexaToTriangle.begin();
610      SurfaceMeshGenerator::Internals::ListOfHexaToTriangle::iterator
611        erhexa=listOfHexaToTriangle.erase(ithexa);
612      ithexa=listOfHexaToTriangle.begin();
613      erhexa=listOfHexaToTriangle.erase(ithexa);
614      listOfHexaToTriangle.push_front(new std::map<const Cell*, std::list<Triangle*> >);
615      ithexa=listOfHexaToTriangle.begin();
616      
617      for(size_t size=0 ; size<sizeinter ; ++size) {
618        triangleListIntersection[size]=triangleListIntersectionNew[size];
619        (*(*ithexa))[&triangleListIntersection[size].mother()].push_back(&triangleListIntersection[size]);
620      }
621      triangleListIntersectionNew.clear();
622      
623      //copy meshes not intersected of object 0 and 1
624      ReferenceCounting<Vector<Triangle> > triangleListTemp;
625      size_t size=0;
626      SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator
627        triangleit=listOfTriangleList.begin();
628      size+=(*(*triangleit)).size();
629      n0=size;
630      ++triangleit;
631      size+=(*(*triangleit)).size();
632      n1=size;
633      triangleListTemp=new Vector<Triangle>(size);
634      triangleit=listOfTriangleList.begin();
635      for(size_t s=0 ; s<(*(*triangleit)).size() ; ++s) {
636        (*triangleListTemp)[s]=(*(*triangleit))[s];
637      }
638      size_t numsize=(*(*triangleit)).size();
639      ++triangleit;
640      for(size_t s=0 ; s<(*(*triangleit)).size() ; ++s) {
641        (*triangleListTemp)[numsize+s]=(*(*triangleit))[s];
642      }
643      
644      it=listOfTriangleList.begin();
645      er=listOfTriangleList.erase(it);
646      it=listOfTriangleList.begin();
647      er=listOfTriangleList.erase(it);
648      listOfTriangleList.push_front(new Vector<Triangle>(size));
649      it=listOfTriangleList.begin();
650      for(size_t s=0 ; s<(*triangleListTemp).size() ; ++s) {
651        (*(*it))[s]=(*triangleListTemp)[s];
652      }
653      
654    }
655    
656    void SurfaceMeshGenerator::Internals::__dataStructureConvertion(const size_t nb)
657    {
658      for (size_t numObj = 0; numObj<nb; ++numObj) {
659        // Data structure convertion
660        {
661    #warning keep this ?
662          size_t n=0;
663          
664          ReferenceCounting<Vector<Vertex*> > pVertexList
665            = new Vector<Vertex*>((*verticesListes[numObj]).size());
666          listOfVertexList.push_back(pVertexList);
667          Vector<Vertex*>& vertexList = *pVertexList;
668          
669          for (SurfaceMeshGenerator::Internals::VerticesList::iterator
670                 i = (*verticesListes[numObj]).begin();
671               i != (*verticesListes[numObj]).end(); ++i, ++n) {
672            vertexList[n] = (*i).second;
673          }
674        }
675        
676        {
677          size_t n=0;
678          
679          ReferenceCounting<Vector<Triangle> > pTriangleList
680            = new Vector<Triangle> ((*triangleListes[numObj]).size());
681          listOfTriangleList.push_back(pTriangleList);
682          Vector<Triangle>& triangleList = *pTriangleList;
683          
684          SurfaceMeshGenerator::Internals::MotherCellList::iterator
685            itcell=(*cellListObject[numObj]).begin();
686          for (SurfaceMeshGenerator::Internals::EdgePairList::iterator
687                 i = (*triangleListes[numObj]).begin();
688               i != (*triangleListes [numObj]).end(); ++i, ++n) {
689            SurfaceMeshGenerator::Internals::VerticesList& V = (*verticesListes[numObj]);
690            Triangle T(* V[(*i)[0]],
691                       * V[(*i)[1]],
692                       * V[(*i)[2]], 1);
693            
694    #warning Store mother cell here
695            T.setMother(*itcell);
696            triangleList[n] = T;
697            ++itcell;
698          }
699        }
700        
701        //(*verticesListes[numObj]).clear();
702        (*triangleListes[numObj]).clear();
703        
704        // Intersection lists
705        
706        {
707    #warning keep this ?
708          size_t n=0;
709          ReferenceCounting<Vector<Vertex*> > pVertexListIntersection
710            = new Vector<Vertex*> ((*verticesListesIntersection[numObj]).size());
711          listOfVertexListIntersection.push_back(pVertexListIntersection);
712          Vector<Vertex*>& vertexListIntersection = *pVertexListIntersection;
713          
714          //for not have double points
715          for (SurfaceMeshGenerator::Internals::VerticesList::iterator
716                 i = (*verticesListesIntersection[numObj]).begin();
717               i != (*verticesListesIntersection[numObj]).end(); ++i, ++n) {
718            if ((*verticesListes[numObj]).find((*i).first)
719                !=(*verticesListes[numObj]).end()) {
720              //ffout(0)<<"point existe deja\n";
721              SurfaceMeshGenerator::Internals::VerticesList::iterator
722                j=(*verticesListes[numObj]).find((*i).first);
723              vertexListIntersection[n] = (*j).second;
724            } else {
725              vertexListIntersection[n] = (*i).second;
726              (*verticesListes[numObj])[(*i).first]
727                =(*i).second;
728            }
729          }
730        }
731        (*verticesListesIntersection[numObj]).clear();
732        {
733          size_t n=0;
734          
735    #warning precompute this:
736          size_t size = 0;
737          for (SurfaceMeshGenerator::Internals::TriangleListesIntersectionEdgesPerHexa::iterator
738                 i = triangleListesIntersectionEdgesPerHexa.begin();
739               i != triangleListesIntersectionEdgesPerHexa.end(); ++i) {
740            size += (*(*i).second[numObj]).size();
741          }
742          
743          ReferenceCounting<Vector<Triangle> > pTriangleListIntersection
744            = new Vector<Triangle>(size);
745          listOfTriangleListIntersection.push_back(pTriangleListIntersection);
746          Vector<Triangle>& triangleListIntersection = *pTriangleListIntersection;
747          
748          ReferenceCounting<std::map<const Cell*, std::list<Triangle*> > > pHexaToTriangle
749            = new std::map<const Cell*, std::list<Triangle*> >;
750          listOfHexaToTriangle.push_back(pHexaToTriangle);
751          std::map<const Cell*, std::list<Triangle*> >& hexaToTriangle = *pHexaToTriangle;
752          
753          for (SurfaceMeshGenerator::Internals::TriangleListesIntersectionEdgesPerHexa::iterator
754                 i = triangleListesIntersectionEdgesPerHexa.begin();
755               i != triangleListesIntersectionEdgesPerHexa.end(); ++i) {
756            for (SurfaceMeshGenerator::Internals::EdgePairList::iterator
757                   j = (*(*i).second[numObj]).begin();
758                 j !=  (*(*i).second[numObj]).end(); ++j) {
759              SurfaceMeshGenerator::Internals::VerticesList& V = (*verticesListes[numObj]);
760              Triangle T(* V[(*j)[0]],
761                         * V[(*j)[1]],
762                         * V[(*j)[2]], 1);
763              
764              T.setMother((*i).first);
765              
766              triangleListIntersection[n] = T;
767              
768              hexaToTriangle[(*i).first].push_back(&triangleListIntersection[n]);
769              ++n;
770            }
771          }
772        }
773        
774        (*verticesListes[numObj]).clear();
775      }
776      
777      triangleListesIntersectionEdgesPerHexa.clear();
778      
779    }
780    
781  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
782  __calculatePointsIntersection(const Scene& scene,  __calculatePointsIntersection(const Scene& scene,
783                                size_t no,                                size_t number0,
784                                size_t no2)                                size_t number1)
785  {  {
786    size_t nobject=scene.nbObjects();    size_t nobject=scene.nbObjects();
787    
788    if(no< nobject and no2<nobject) {    if(number0< nobject and number1<nobject) {
789      ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();      ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();
790      ListOfHexaToTriangle::iterator hexait0=hexait;      ListOfHexaToTriangle::iterator hexait0=hexait;
791      ++hexait;      ++hexait;
# Line 615  __calculatePointsIntersection(const Scen Line 804  __calculatePointsIntersection(const Scen
804              jt0!=listTriangle0.end() ; ++jt0) {              jt0!=listTriangle0.end() ; ++jt0) {
805            for(std::list<Triangle*>::iterator jt1=listTriangle1.begin() ;            for(std::list<Triangle*>::iterator jt1=listTriangle1.begin() ;
806                jt1!=listTriangle1.end() ; ++jt1) {                jt1!=listTriangle1.end() ; ++jt1) {
807              __createPointIntersection(no,no2,jt0,jt1);              __createPointIntersection(number0,number1,jt0,jt1);
808            }            }
809          }          }
810        } else {        } else {
# Line 697  TinyVector<3,const Vertex*> Line 886  TinyVector<3,const Vertex*>
886  SurfaceMeshGenerator::Internals::__determinatePinterNotInList(const TriangleCut& K,  SurfaceMeshGenerator::Internals::__determinatePinterNotInList(const TriangleCut& K,
887                                                                TinyVector<3,size_t> ncase)                                                                TinyVector<3,size_t> ncase)
888  {  {
889    TinyVector<3,const Vertex*> ABC;    TinyVector<3,const Vertex*> triangle;
890    ABC[0]=(K.pointsIntersection[ncase[0]][0]);    triangle[0]=(K.pointsIntersection[ncase[0]][0]);
891    if(K.pointsIntersection[ncase[1]][0]!=ABC[0]) {    if(K.pointsIntersection[ncase[1]][0]!=triangle[0]) {
892      ABC[1]=(K.pointsIntersection[ncase[1]][0]);      triangle[1]=(K.pointsIntersection[ncase[1]][0]);
893    } else {    } else {
894      ABC[1]=(K.pointsIntersection[ncase[1]][1]);      triangle[1]=(K.pointsIntersection[ncase[1]][1]);
895    }    }
896    
897    if(K.pointsIntersection[ncase[2]][0]!=ABC[0] and K.pointsIntersection[ncase[2]][0]!=ABC[1]) {    if(K.pointsIntersection[ncase[2]][0]!=triangle[0] and K.pointsIntersection[ncase[2]][0]!=triangle[1]) {
898      ABC[2]=(K.pointsIntersection[ncase[2]][0]);      triangle[2]=(K.pointsIntersection[ncase[2]][0]);
899    } else {    } else {
900      ABC[2]=(K.pointsIntersection[ncase[2]][1]);      triangle[2]=(K.pointsIntersection[ncase[2]][1]);
901    }    }
902    
903    return ABC;    return triangle;
904  }  }
905    
906  void SurfaceMeshGenerator::Internals::__casePinterNotInList(const TriangleCut& K,  void SurfaceMeshGenerator::Internals::__casePinterNotInList(const TriangleCut& K,
907                                                              const Cell* cell){                                                              const Cell* cell){
908    TinyVector<3,const Vertex*> ABC;    TinyVector<3,const Vertex*> triangle;
909    TinyVector<3,size_t> ncase;    TinyVector<3,size_t> ncase;
910    if(K.pointsIntersection[0][0]==K.pointsIntersection[0][1]) {    if(K.pointsIntersection[0][0]==K.pointsIntersection[0][1]) {
911      ncase[0]=0;      ncase[0]=0;
912      ncase[1]=1;      ncase[1]=1;
913      ncase[2]=2;      ncase[2]=2;
914      ABC=__determinatePinterNotInList(K,ncase);      triangle=__determinatePinterNotInList(K,ncase);
915    } else {    } else {
916      if(K.pointsIntersection[1][0]==K.pointsIntersection[1][1]) {      if(K.pointsIntersection[1][0]==K.pointsIntersection[1][1]) {
917        ncase[0]=1;        ncase[0]=1;
918        ncase[1]=0;        ncase[1]=0;
919        ncase[2]=2;        ncase[2]=2;
920        ABC=__determinatePinterNotInList(K,ncase);        triangle=__determinatePinterNotInList(K,ncase);
921      } else {      } else {
922        if(K.pointsIntersection[2][0]==K.pointsIntersection[2][1]) {        if(K.pointsIntersection[2][0]==K.pointsIntersection[2][1]) {
923          ncase[0]=2;          ncase[0]=2;
924          ncase[1]=1;          ncase[1]=1;
925          ncase[2]=0;          ncase[2]=0;
926          ABC=__determinatePinterNotInList(K,ncase);          triangle=__determinatePinterNotInList(K,ncase);
927        } else {        } else {
928          ABC[0]=K.pointsIntersection[0][0];          triangle[0]=K.pointsIntersection[0][0];
929          ABC[1]=K.pointsIntersection[1][0];          triangle[1]=K.pointsIntersection[1][0];
930          ABC[2]=K.pointsIntersection[2][0];          triangle[2]=K.pointsIntersection[2][0];
931        }        }
932      }      }
933    }    }
934    __addTriangle(*ABC[0],*ABC[1],*ABC[2],cell);    __addTriangle(*triangle[0],*triangle[1],*triangle[2],cell);
935  }  }
936    
937  void SurfaceMeshGenerator::Internals::plotini(size_t nobjectToTreat) {  void SurfaceMeshGenerator::Internals::plotini(size_t nobjectToTreat) {
# Line 1117  __CalculPoint(const size_t& objectNumber Line 1306  __CalculPoint(const size_t& objectNumber
1306    
1307  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
1308  __inout(const size_t& numobject,  __inout(const size_t& numobject,
1309          const int & ttn0,          const int & edgeCut,
1310          const Vertex*& V0,          const Vertex*& V0,
1311          const Vertex*& V1)          const Vertex*& V1)
1312  {  {
1313    size_t& re0=(*edgesRefVertex[numobject])[V0];    size_t& refVertex0=(*edgesRefVertex[numobject])[V0];
1314    size_t& re1=(*edgesRefVertex[numobject])[V1];    size_t& refVertex1=(*edgesRefVertex[numobject])[V1];
1315    
1316    if(re0+re1==4 and ttn0==1) {    if(refVertex0+refVertex1==4 and edgeCut==1) {
1317      ffout(0)<<"warning edge ref 2 cut \n";      ffout(0)<<"warning edge ref 2 cut \n";
1318      ffout(0)<<(*V0).Vector3()[0]<<" "<<(*V0).Vector3()[1]<<" "<<(*V0).Vector3()[2]<<" \n";      ffout(0)<<(*V0).Vector3()[0]<<" "<<(*V0).Vector3()[1]<<" "<<(*V0).Vector3()[2]<<" \n";
1319      ffout(0)<<(*V1).Vector3()[0]<<" "<<(*V1).Vector3()[1]<<" "<<(*V1).Vector3()[2]<<" \n";      ffout(0)<<(*V1).Vector3()[0]<<" "<<(*V1).Vector3()[1]<<" "<<(*V1).Vector3()[2]<<" \n";
1320      re0=0;      refVertex0=0;
1321      re1=0;      refVertex1=0;
1322    } else {    } else {
1323      // CECILE: ne serait-ce pas plutôt une assertion ?      // CECILE: ne serait-ce pas plutôt une assertion ?
1324      if(re0+re1==2 and ttn0==0) {      if(refVertex0+refVertex1==2 and edgeCut==0) {
1325        re0=2;        refVertex0=2;
1326        re1=2;        refVertex1=2;
1327      }      }
1328    }    }
1329  }  }
# Line 1205  __createPointIntersection(const size_t& Line 1394  __createPointIntersection(const size_t&
1394    
1395    
1396  const Vertex& SurfaceMeshGenerator::Internals::  const Vertex& SurfaceMeshGenerator::Internals::
1397  __determinateNumber(const int& p,  __determinateNumber(const int& place,
1398                      const TinyVector<3,TinyVector<2,const Vertex*> >& pointsint)                      const TinyVector<3,TinyVector<2,const Vertex*> >& pointsint)
1399  {  {
1400    if(p<=2) {    if(place<=2) {
1401      return *pointsint[p][0];      return *pointsint[place][0];
1402    } else {    } else {
1403      return *pointsint[2][0];      return *pointsint[2][0];
1404    }    }
# Line 1231  __addTriangle(const Vertex& V0, Line 1420  __addTriangle(const Vertex& V0,
1420  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
1421  __determinateCase(const int& ncase,  __determinateCase(const int& ncase,
1422                    const TriangleCut & K,                    const TriangleCut & K,
1423                    TinyVector<3,int>& tt,                    TinyVector<3,int>& edgesCut,
1424                    TinyVector<3,int>& pp)                    TinyVector<3,int>& vertexNum)
1425  {  {
1426    const TinyVector<3,TinyVector<2,int> >& tt2=K.edgecut;    const TinyVector<3,TinyVector<2,int> >& edgesCut2=K.edgecut;
1427    switch(ncase) {        switch(ncase) {    
1428    case 0: {    case 0: {
1429      tt[0]=tt2[0][0];      edgesCut[0]=edgesCut2[0][0];
1430      tt[1]=tt2[1][0];      edgesCut[1]=edgesCut2[1][0];
1431      tt[2]=tt2[2][0];      edgesCut[2]=edgesCut2[2][0];
1432      pp[0]=0;      vertexNum[0]=0;
1433      pp[1]=1;      vertexNum[1]=1;
1434      pp[2]=2;      vertexNum[2]=2;
1435      break;      break;
1436    }    }
1437    case 1: {    case 1: {
1438      tt[0]=tt2[0][0];      edgesCut[0]=edgesCut2[0][0];
1439      tt[1]=tt2[2][0];      edgesCut[1]=edgesCut2[2][0];
1440      tt[2]=tt2[1][0];      edgesCut[2]=edgesCut2[1][0];
1441      pp[0]=0;      vertexNum[0]=0;
1442      pp[1]=2;      vertexNum[1]=2;
1443      pp[2]=1;      vertexNum[2]=1;
1444      break;      break;
1445    }    }
1446    case 2: {    case 2: {
1447      tt[0]=tt2[1][0];      edgesCut[0]=edgesCut2[1][0];
1448      tt[1]=tt2[2][0];      edgesCut[1]=edgesCut2[2][0];
1449      tt[2]=tt2[0][0];      edgesCut[2]=edgesCut2[0][0];
1450      pp[0]=1;      vertexNum[0]=1;
1451      pp[1]=2;      vertexNum[1]=2;
1452      // CECILE: est-il normal que pp[2] ne soit pas défini ?      vertexNum[2]=0;
1453      break;      break;
1454    }    }
1455    }    }
# Line 1275  __createCase1(int ncase, Line 1464  __createCase1(int ncase,
1464    const Vertex& V1=K(1);    const Vertex& V1=K(1);
1465    const Vertex& V2=K(2);    const Vertex& V2=K(2);
1466            
1467    const TinyVector<3,TinyVector<2,const Vertex*> >& pointsint=K.pointsIntersection;    const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection;
1468    const std::map< const Vertex* ,const Vertex* >& pointsin=K.pointsin;    const std::map< const Vertex* ,const Vertex* >& pointsInterior=K.pointsin;
1469    const size_t& numberin=pointsin.size();    const size_t& numberPointsInterior=pointsInterior.size();
1470    const Vertex& A=K(ncase);    const Vertex& A=K(ncase);
1471    
1472    TinyVector<3,int> tt;    TinyVector<3,int> edgesCut;
1473    TinyVector<3,int> pp;    TinyVector<3,int> vertexNum;
1474    
1475    __determinateCase(ncase,K,tt,pp);    __determinateCase(ncase,K,edgesCut,vertexNum);
1476    
1477    switch (numberin) {    switch (numberPointsInterior) {
1478    case 0: {    case 0: {
1479      if(tt[0]==1) {      if(edgesCut[0]==1) {
1480        const Vertex& B=__determinateNumber(pp[0],pointsint);        const Vertex& B=__determinateNumber(vertexNum[0],pointsIntersection);
1481        if(tt[1]==1) {        if(edgesCut[1]==1) {
1482          const Vertex& C=__determinateNumber(pp[1],pointsint);          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);
1483          __addTriangle(A,B,C,cell);          __addTriangle(A,B,C,cell);
1484        } else {        } else {
1485          ffout(0) <<"pbs 10\n"<<std::flush;          ffout(0) <<"pbs 10\n"<<std::flush;
# Line 1299  __createCase1(int ncase, Line 1488  __createCase1(int ncase,
1488          ffout(0)<<V2.Vector3()<<"\n";          ffout(0)<<V2.Vector3()<<"\n";
1489        }        }
1490      } else {      } else {
1491        if(tt[1]==1) {        if(edgesCut[1]==1) {
1492          ffout(0)<<"pbs 11\n"<<std::flush;          ffout(0)<<"pbs 11\n"<<std::flush;
1493        } else {        } else {
1494          ffout(0) <<"pbs 111\n";          ffout(0) <<"pbs 111\n";
# Line 1308  __createCase1(int ncase, Line 1497  __createCase1(int ncase,
1497      break;      break;
1498    }    }
1499    case 1: {    case 1: {
1500      std::map<const Vertex*,const Vertex*>::const_iterator it=pointsin.begin();      std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();
1501      const Vertex&  D=*((*it).second);      const Vertex&  D=*((*it).second);
1502      if(tt[0]==1) {      if(edgesCut[0]==1) {
1503        const Vertex& B=__determinateNumber(pp[0],pointsint);        const Vertex& B=__determinateNumber(vertexNum[0],pointsIntersection);
1504        if(tt[1]==1) {        if(edgesCut[1]==1) {
1505          const Vertex& C=__determinateNumber(pp[1],pointsint);          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);
1506          __addTriangle(A,B,D,cell);          __addTriangle(A,B,D,cell);
1507          __addTriangle(A,D,C,cell);          __addTriangle(A,D,C,cell);
1508        } else {        } else {
# Line 1324  __createCase1(int ncase, Line 1513  __createCase1(int ncase,
1513          __addTriangle(A,B,D,cell);          __addTriangle(A,B,D,cell);
1514        }        }
1515      } else {      } else {
1516        if(tt[1]==1) {        if(edgesCut[1]==1) {
1517          ffout(0)<<"-------- warning trou in\n"<<std::flush;          ffout(0)<<"-------- warning trou in\n"<<std::flush;
1518          const Vertex& B=__determinateNumber(pp[1],pointsint);          const Vertex& B=__determinateNumber(vertexNum[1],pointsIntersection);
1519          __addTriangle(A,B,D,cell);          __addTriangle(A,B,D,cell);
1520        } else {        } else {
1521          ffout(0) <<"pbs 1\n"<<std::flush;          ffout(0) <<"pbs 1\n"<<std::flush;
# Line 1337  __createCase1(int ncase, Line 1526  __createCase1(int ncase,
1526    default: {    default: {
1527  #warning is it true?  #warning is it true?
1528      //a faire si plus d' 1 point d'intersection pas dans le triangle      //a faire si plus d' 1 point d'intersection pas dans le triangle
1529      ffout(0) << numberin<<" be careful 1\n"<<std::flush;      ffout(0) << numberPointsInterior<<" be careful 1\n"<<std::flush;
1530      //POUR STEPH :  peut generer des tr plats      //POUR STEPH :  peut generer des tr plats
1531      //  ffout(0)<<V0.Vector3()<<"\n";       // ffout(0)<<V0.Vector3()<<"\n";
1532      //ffout(0)<<V1.Vector3()<<"\n";       // ffout(0)<<V1.Vector3()<<"\n";
1533      //ffout(0)<<V2.Vector3()<<"\n";       // ffout(0)<<V2.Vector3()<<"\n";
1534      TinyVector<10,const Vertex*> P,Ptemp;        __createByEdges(K,cell);
     size_t i=0;  
     for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsin.begin();  
         it!=pointsin.end() ; ++it) {  
       P[i+1]=(*it).second;  
       ++i;  
     }  
   
     if(tt[0]==1) {  
       const Vertex& B=__determinateNumber(pp[0],pointsint);  
       P[0]=&B;  
       if(tt[1]==1) {  
         const Vertex& C=__determinateNumber(pp[1],pointsint);  
         size_t size=numberin+1;  
         for(size_t boucle=0 ; boucle<numberin-1 ; ++boucle) {  
           size_t num=1;  
           real_t norm=Norm((*P[0]).Vector3()-(*P[1]).Vector3());  
           for(size_t i=2 ; i<size ; ++i) {  
             real_t normtemp=Norm((*P[0]).Vector3()-(*P[i]).Vector3());  
             if(normtemp<=norm) {  
               norm=normtemp;  
               Ptemp[i-1]=P[num];  
               num=i;  
             } else {  
               Ptemp[i-1]=P[i];  
             }  
           }  
           __addTriangle(A,*P[0],*P[num],cell);  
           Ptemp[0]=P[num];  
           P=Ptemp;  
           --size;  
           // ffout(0)<<"size = "<<size<<"\n";  
         }  
         __addTriangle(A,*P[0],*P[1],cell);  
         __addTriangle(A,*P[1],C,cell);  
         /*  if(tt[2]==1) {  
             const Vertex& D=__determinateNumber(pp[2],pointsint);  
             for(size_t i=0 ; i<numberin ; ++i) {  
             P[i+1]=(pointsin[i]);  
             }  
             P[0]=&B;  
             size=numberin+1;  
             for(size_t boucle=0 ; boucle<numberin-1 ; ++boucle) {  
             size_t num=1;  
             real_t norm=Norm((*P[0]).Vector3()-(*P[1]).Vector3());  
             for(size_t i=2 ; i<size ; ++i) {  
             real_t normtemp=Norm((*P[0]).Vector3()-(*P[i]).Vector3());  
             if(normtemp<=norm) {  
             norm=normtemp;  
             Ptemp[i-1]=P[num];  
             num=i;  
             }  
             else {  
             Ptemp[i-1]=P[i];  
             }  
             }  
             __addTriangle(D,*P[0],*P[num],cell);  
             Ptemp[0]=P[num];  
             P=Ptemp;  
             --size;  
             // ffout(0)<<"size = "<<size<<"\n";  
             }  
             __addTriangle(D,*P[0],*P[1],cell);  
               //  __addTriangle(D,*P[1],C,cell);  
               }*/  
       } else {  
         ffout(0)<<"une seule arete cut pbs\n";  
       }  
     } else {  
       ffout(0)<<"une seule arete cut pbs2\n";  
     }  
1535    }    }
1536    }    }
1537  }  }
# Line 1421  void SurfaceMeshGenerator::Internals:: Line 1540  void SurfaceMeshGenerator::Internals::
1540  __createCase2(int ncase,  __createCase2(int ncase,
1541                const TriangleCut& K,                const TriangleCut& K,
1542                const Cell* cell)                const Cell* cell)
1543  {    {
1544    int ttn0,ttn1;    TinyVector<2,int> edgesCut;
1545    int p0,p1;    TinyVector<2,int> vertexNum;
1546    const Vertex& V0=K(0);    const Vertex& V0=K(0);
1547    const Vertex& V1=K(1);    const Vertex& V1=K(1);
1548    const Vertex& V2=K(2);    const Vertex& V2=K(2);
1549    
1550    const TinyVector<3,TinyVector<2,const Vertex*> >& pointsint=K.pointsIntersection;    const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection;
1551    const std::map<const Vertex* ,const Vertex*>& pointsin=K.pointsin;    const std::map<const Vertex* ,const Vertex*>& pointsInterior=K.pointsin;
1552    const TinyVector<3,TinyVector<2,int> >&  tt2=K.edgecut;    const TinyVector<3,TinyVector<2,int> >&  edgesCut2=K.edgecut;
1553    const int& numberin=pointsin.size();    const int& numberPointsInterior=pointsInterior.size();
1554    
1555    size_t ncase0=0,ncase1=1;    size_t ncase0=0,ncase1=1;
1556    switch (ncase) {    switch (ncase) {
1557    case 0: {    case 0: {
1558      ttn0=tt2[1][0];      edgesCut[0]=edgesCut2[1][0];
1559      ttn1=tt2[2][0];      edgesCut[1]=edgesCut2[2][0];
1560      p0=1;      vertexNum[0]=1;
1561      p1=2;      vertexNum[1]=2;
1562      break;      break;
1563    }    }
1564    case 1: {    case 1: {
1565      ttn0=tt2[0][0];      edgesCut[0]=edgesCut2[0][0];
1566      ttn1=tt2[2][0];      edgesCut[1]=edgesCut2[2][0];
1567      p0=0;      vertexNum[0]=0;
1568      p1=2;      vertexNum[1]=2;
1569      ncase0=0;      ncase0=0;
1570      ncase1=2;      ncase1=2;
1571      break;      break;
1572    }    }
1573    case 2: {    case 2: {
1574      ttn0=tt2[0][0];      edgesCut[0]=edgesCut2[0][0];
1575      ttn1=tt2[1][0];      edgesCut[1]=edgesCut2[1][0];
1576      p0=0;      vertexNum[0]=0;
1577      p1=1;      vertexNum[1]=1;
1578      ncase0=1;      ncase0=1;
1579      ncase1=2;      ncase1=2;
1580    }    }
# Line 1464  __createCase2(int ncase, Line 1583  __createCase2(int ncase,
1583    const Vertex& A=K(ncase0);    const Vertex& A=K(ncase0);
1584    const Vertex& B=K(ncase1);    const Vertex& B=K(ncase1);
1585    
1586    switch (numberin) {    switch (numberPointsInterior) {
1587    case 0: {    case 0: {
1588      if(ttn0==1) {      if(edgesCut[0]==1) {
1589        const Vertex& C=__determinateNumber(p0,pointsint);        const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);
1590        if(ttn1==1) {        if(edgesCut[1]==1) {
1591          const Vertex& D=__determinateNumber(p1,pointsint);          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1592          __addTriangle(A,B,C,cell);          __addTriangle(A,B,C,cell);
1593          __addTriangle(C,B,D,cell);          __addTriangle(C,B,D,cell);
1594        } else {        } else {
# Line 1477  __createCase2(int ncase, Line 1596  __createCase2(int ncase,
1596          __addTriangle(A,B,C,cell);          __addTriangle(A,B,C,cell);
1597        }        }
1598      } else {      } else {
1599        if(ttn1==1) {        if(edgesCut[1]==1) {
1600          // ffout(0) <<"pbs 210\n";          // ffout(0) <<"pbs 210\n";
1601          const Vertex& C=__determinateNumber(p1,pointsint);          const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection);
1602          __addTriangle(A,B,C,cell);          __addTriangle(A,B,C,cell);
1603        } else {        } else {
1604          ffout(0) <<"pbs 21\n"<<std::flush;          ffout(0) <<"pbs 21\n"<<std::flush;
# Line 1491  __createCase2(int ncase, Line 1610  __createCase2(int ncase,
1610      break;      break;
1611    }    }
1612    case 1: {    case 1: {
1613      std::map<const Vertex*,const Vertex*>::const_iterator it=pointsin.begin();      std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();
1614      const Vertex& E=*((*it).second);      const Vertex& E=*((*it).second);
1615    
1616      if(ttn0==1) {      if(edgesCut[0]==1) {
1617        const Vertex& C=__determinateNumber(p0,pointsint);        const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);
1618        if(ttn1==1) {        if(edgesCut[1]==1) {
1619          const Vertex& D=__determinateNumber(p1,pointsint);          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1620          __addTriangle(A,C,E,cell);          __addTriangle(A,C,E,cell);
1621          __addTriangle(A,E,B,cell);          __addTriangle(A,E,B,cell);
1622          __addTriangle(B,E,D,cell);          __addTriangle(B,E,D,cell);
# Line 1506  __createCase2(int ncase, Line 1625  __createCase2(int ncase,
1625          __addTriangle(C,E,B,cell);          __addTriangle(C,E,B,cell);
1626        }        }
1627      } else {      } else {
1628        if(ttn1==1) {        if(edgesCut[1]==1) {
1629          const Vertex& D=__determinateNumber(p1,pointsint);          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1630          __addTriangle(D,E,B,cell);          __addTriangle(D,E,B,cell);
1631          __addTriangle(A,B,E,cell);          __addTriangle(A,B,E,cell);
1632        } else {        } else {
# Line 1516  __createCase2(int ncase, Line 1635  __createCase2(int ncase,
1635      }      }
1636      break;      break;
1637    }    }
1638    case 2: {    default: {
1639      //POUR STEPH :  peut generer des tr plats      //POUR STEPH :  peut generer des tr plats
1640      ffout(0) << numberin <<"be careful 2\n"<<std::flush;      ffout(0) << numberPointsInterior <<"be careful 2\n"<<std::flush;
1641      //     ffout(0)<<V0.Vector3()<<"\n";      //     ffout(0)<<V0.Vector3()<<"\n";
1642      //   ffout(0)<<V1.Vector3()<<"\n";      //   ffout(0)<<V1.Vector3()<<"\n";
1643      // ffout(0)<<V2.Vector3()<<"\n";      // ffout(0)<<V2.Vector3()<<"\n";
1644      TinyVector<10,const Vertex*> P,Ptemp;      TinyVector<10,const Vertex*> P,Ptemp;
1645      size_t i=0;      size_t i=0;
1646      for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsin.begin();      for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin();
1647          it!=pointsin.end() ; ++it) {          it!=pointsInterior.end() ; ++it) {
1648        P[i+1]=(*it).second;        P[i+1]=(*it).second;
1649        ++i;        ++i;
1650      }      }
# Line 1534  __createCase2(int ncase, Line 1653  __createCase2(int ncase,
1653      // veux-tu vérifier simplement que l'assertion est vérifiée ?      // veux-tu vérifier simplement que l'assertion est vérifiée ?
1654      // Dans ce cas, il serait bien préférable d'utiliser assert()      // Dans ce cas, il serait bien préférable d'utiliser assert()
1655    
1656      if(ttn0==1) {      if(edgesCut[0]==1) {
1657        const Vertex& C=__determinateNumber(p0,pointsint);        const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection);
1658        __addTriangle(A,B,C,cell);        __addTriangle(A,B,C,cell);
1659        P[0]=&C;        P[0]=&C;
1660        if(ttn1==1) {        if(edgesCut[1]==1) {
1661          const Vertex& D=__determinateNumber(p1,pointsint);          const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection);
1662          size_t size=numberin+1;          size_t size=numberPointsInterior+1;
1663          for(size_t boucle=0 ; boucle<numberin-1 ; ++boucle) {          for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) {
1664            size_t num=1;            size_t num=1;
1665            real_t norm=Norm((*P[0]).Vector3()-(*P[1]).Vector3());            real_t norm=Norm((*P[0]).Vector3()-(*P[1]).Vector3());
1666            for(size_t i=2 ; i<size ; ++i) {            for(size_t i=2 ; i<size ; ++i) {
# Line 1579  __createLocalListIntersection(const size Line 1698  __createLocalListIntersection(const size
1698                                TriangleCut & K,                                TriangleCut & K,
1699                                const Cell* cell)                                const Cell* cell)
1700  {  {
1701    TinyVector<3,TinyVector<2,int> >& tt=K.edgecut;    TinyVector<3,TinyVector<2,int> >& edgesCut=K.edgecut;
1702    TinyVector<3,TinyVector<2,const Vertex*> > & pointsIntersection=K.pointsIntersection;    TinyVector<3,TinyVector<2,const Vertex*> > & pointsIntersection=K.pointsIntersection;
1703    std::map<const Vertex* ,const Vertex*>& pointsin=K.pointsin;    std::map<const Vertex* ,const Vertex*>& pointsInterior=K.pointsin;
1704    
1705    int numberin=pointsin.size();    int numberPointsInterior=pointsInterior.size();
1706    const size_t& numobject=K.numobject;    const size_t& numobject=K.numobject;
1707    
1708    ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();    ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();
# Line 1602  __createLocalListIntersection(const size Line 1721  __createLocalListIntersection(const size
1721      for(std::list<Triangle*>::iterator jt0=listTriangle1.begin() ;      for(std::list<Triangle*>::iterator jt0=listTriangle1.begin() ;
1722          jt0!=listTriangle1.end() ; ++jt0) {          jt0!=listTriangle1.end() ; ++jt0) {
1723    
1724        PairTriangleNew pT;        PairTriangleNew pairTriangle;
1725        if(numobject<objectNumber) {        if(numobject<objectNumber) {
1726          pT.first=(currentTriangle);          pairTriangle.first=(currentTriangle);
1727          pT.second=(*jt0);          pairTriangle.second=(*jt0);
1728        } else {        } else {
1729          pT.second=(currentTriangle);          pairTriangle.second=(currentTriangle);
1730          pT.first=(*jt0);          pairTriangle.first=(*jt0);
1731        }        }
1732        size_t temp=0;        size_t temp=0;
1733                            
1734        if(pairTriangleToIntersectionPoints.find(pT)!=pairTriangleToIntersectionPoints.end()) {        if(pairTriangleToIntersectionPoints.find(pairTriangle)!=pairTriangleToIntersectionPoints.end()) {
1735          TinyVector<3,size_t > cc;          TinyVector<3,size_t > cutTriangle;
1736          if(numobject<objectNumber) {          if(numobject<objectNumber) {
1737            cc=(pairTriangleToIntersectionPoints[pT]).cutTriangle1;            cutTriangle=(pairTriangleToIntersectionPoints[pairTriangle]).cutTriangle1;
1738          } else {          } else {
1739            cc=(pairTriangleToIntersectionPoints[pT]).cutTriangle2;            cutTriangle=(pairTriangleToIntersectionPoints[pairTriangle]).cutTriangle2;
1740          }          }
1741          //detection tr plat          //detection tr plat
1742          size_t isDegenerate=0;          size_t isDegenerate=0;
# Line 1625  __createLocalListIntersection(const size Line 1744  __createLocalListIntersection(const size
1744            // ffout(0)<<"degenerate triangle\n";            // ffout(0)<<"degenerate triangle\n";
1745            isDegenerate=1;            isDegenerate=1;
1746          }          }
1747          if(pairTriangleToIntersectionPoints[pT].size()==2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) {
1748            const Vertex*& V0=pairTriangleToIntersectionPoints[pT].listofPoints[0];            const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle].listofPoints[0];
1749            const Vertex*& V1=pairTriangleToIntersectionPoints[pT].listofPoints[1];            const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle].listofPoints[1];
1750            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))            if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2))
1751               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {               and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) {
1752              //ffout(0)<<"inter confondu avec arete\n";              //ffout(0)<<"inter confondu avec arete\n";
1753              isDegenerate=1;              isDegenerate=1;
1754            }            }
1755          }          }
1756          if(pairTriangleToIntersectionPoints[pT].size()>=2 and isDegenerate==0) {          if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) {
1757            for(size_t b=0; b<pairTriangleToIntersectionPoints[pT].size() ; ++b) {            for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) {
1758              const Vertex*& V=pairTriangleToIntersectionPoints[pT].listofPoints[b];              const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle].listofPoints[b];
1759              if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) or b==0) {              if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) or b==0) {
1760                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {                if(vertexInTriangles.find(V)==vertexInTriangles.end()) {
1761                  TinyVector<2,const Triangle*> TT;                  TinyVector<2,const Triangle*> triangles;
1762                  TT[0]=*jt0;                  triangles[0]=*jt0;
1763                  TT[1]=*jt0;                  triangles[1]=*jt0;
1764                  vertexInTriangles[V]=TT;                  vertexInTriangles[V]=triangles;
1765                } else {                } else {
1766                  (*vertexInTriangles.find(V)).second[1]=*jt0;                  (*vertexInTriangles.find(V)).second[1]=*jt0;
1767                }                }
1768                if(triangleWithVertex.find(*jt0)==triangleWithVertex.end()) {                if(triangleWithVertex.find(*jt0)==triangleWithVertex.end()) {
1769                  TinyVector<2,const Vertex*> VV;                  TinyVector<2,const Vertex*> vertexTriangle;
1770                  VV[0]=V;                  vertexTriangle[0]=V;
1771                  VV[1]=V;                  vertexTriangle[1]=V;
1772                  triangleWithVertex[*jt0]=VV;                  triangleWithVertex[*jt0]=vertexTriangle;
1773                } else {                } else {
1774                  (*triangleWithVertex.find(*jt0)).second[1]=V;                  (*triangleWithVertex.find(*jt0)).second[1]=V;
1775                }                }
# Line 1658  __createLocalListIntersection(const size Line 1777  __createLocalListIntersection(const size
1777            }            }
1778          }          }
1779    
1780          for (size_t n=0; n < cc.size(); ++n) {          for (size_t n=0; n < cutTriangle.size(); ++n) {
1781            if(cc[n]!=0) {            if(cutTriangle[n]!=0) {
1782              temp+=1;              temp+=1;
1783              if(tt[n][0]==0) {              if(edgesCut[n][0]==0) {
1784                tt[n][0]=1;                edgesCut[n][0]=1;
1785                pointsIntersection[n][0]=                pointsIntersection[n][0]=
1786                  (pairTriangleToIntersectionPoints[pT].listofPoints[cc[n]-1]);                  (pairTriangleToIntersectionPoints[pairTriangle].listofPoints[cutTriangle[n]-1]);
1787              } else {              } else {
1788                tt[n][1]=1;                edgesCut[n][1]=1;
1789                pointsIntersection[n][1]=                pointsIntersection[n][1]=
1790                  (pairTriangleToIntersectionPoints[pT].listofPoints[cc[n]-1]);                  (pairTriangleToIntersectionPoints[pairTriangle].listofPoints[cutTriangle[n]-1]);
1791              }              }
1792            }            }
1793          }          }
1794    
1795          if(temp<pairTriangleToIntersectionPoints[pT].size()) {          if(temp<pairTriangleToIntersectionPoints[pairTriangle].size()) {
1796            numberin+=1;            numberPointsInterior+=1;
1797            size_t r=0;            size_t r=0;
1798            size_t sum=cc[0]+cc[1]+cc[2];            size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2];
1799            if(sum>3) {            if(sum>3) {
1800              ffout(0)<<"sum "<<sum<<"\n"<<std::flush;              ffout(0)<<"sum "<<sum<<"\n"<<std::flush;
1801            }            }
# Line 1684  __createLocalListIntersection(const size Line 1803  __createLocalListIntersection(const size
1803            switch (sum) {            switch (sum) {
1804            case 0: {            case 0: {
1805              r=0;              r=0;
1806              for(size_t i=1 ; i<pairTriangleToIntersectionPoints[pT].size() ;++i)              for(size_t i=1 ; i<pairTriangleToIntersectionPoints[pairTriangle].size() ;++i)
1807                pointsin[(pairTriangleToIntersectionPoints[pT].listofPoints[i])]=                pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle].listofPoints[i])]=
1808                  (pairTriangleToIntersectionPoints[pT].listofPoints[i]);                  (pairTriangleToIntersectionPoints[pairTriangle].listofPoints[i]);
1809              break;              break;
1810            }            }
1811            case 2:            case 2:
# Line 1704  __createLocalListIntersection(const size Line 1823  __createLocalListIntersection(const size
1823            }            }
1824            default: {            default: {
1825              ffout(0) << "pbs sum = "<<sum<<" size "              ffout(0) << "pbs sum = "<<sum<<" size "
1826                       << pairTriangleToIntersectionPoints[pT].size()<<" \n";                       << pairTriangleToIntersectionPoints[pairTriangle].size()<<" \n";
1827              ffout(0) << K(0) << "\n";              ffout(0) << K(0) << "\n";
1828              ffout(0) << K(1) << "\n";              ffout(0) << K(1) << "\n";
1829              ffout(0) << K(2) << "\n";              ffout(0) << K(2) << "\n";
1830              ffout(0) << cc[0] << " " << cc[1] << " " << cc[2] << "\n";              ffout(0) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n";
1831            }            }
1832            }            }
1833            if(pointsin.find(pairTriangleToIntersectionPoints[pT].listofPoints[r])            if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle].listofPoints[r])
1834               ==pointsin.end()) {               ==pointsInterior.end()) {
1835              pointsin[(pairTriangleToIntersectionPoints[pT].listofPoints[r])]              pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle].listofPoints[r])]
1836                =(pairTriangleToIntersectionPoints[pT].listofPoints[r]);                =(pairTriangleToIntersectionPoints[pairTriangle].listofPoints[r]);
1837            }            }
1838          }          }
1839        } else {        } else {
# Line 1730  __determinateEdgeCut(const size_t& numob Line 1849  __determinateEdgeCut(const size_t& numob
1849                       const Triangle*& currentTriangle,                       const Triangle*& currentTriangle,
1850                       const Cell* cell){                       const Cell* cell){
1851            
1852    TinyVector<3,TinyVector<2,int> > tt;    TinyVector<3,TinyVector<2,int> > edgesCut;
1853    tt=0;    edgesCut=0;
1854    
1855    ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();    ListOfHexaToTriangle::iterator hexait=listOfHexaToTriangle.begin();
1856    MapCellTriangle hexaToTriangle1;    MapCellTriangle hexaToTriangle1;
# Line 1749  __determinateEdgeCut(const size_t& numob Line 1868  __determinateEdgeCut(const size_t& numob
1868      for(std::list<Triangle*>::iterator jt0=listTriangle1.begin() ;      for(std::list<Triangle*>::iterator jt0=listTriangle1.begin() ;
1869          jt0!=listTriangle1.end() ; ++jt0) {          jt0!=listTriangle1.end() ; ++jt0) {
1870    
1871        PairTriangleNew pT;        PairTriangleNew pairTriangle;
1872        if(numobject<objectNumber) {        if(numobject<objectNumber) {
1873          pT.first=(currentTriangle);          pairTriangle.first=(currentTriangle);
1874          pT.second=(*jt0);          pairTriangle.second=(*jt0);
1875        } else {        } else {
1876          pT.second=(currentTriangle);          pairTriangle.second=(currentTriangle);
1877          pT.first=(*jt0);          pairTriangle.first=(*jt0);
1878        }        }
1879    
1880        if(pairTriangleToIntersectionPoints.find(pT)!=        if(pairTriangleToIntersectionPoints.find(pairTriangle)!=
1881           pairTriangleToIntersectionPoints.end()) {           pairTriangleToIntersectionPoints.end()) {
1882    
1883          TinyVector<3,size_t> cc;          TinyVector<3,size_t> cutTriangle;
1884          if(numobject<objectNumber) {          if(numobject<objectNumber) {
1885            cc=(pairTriangleToIntersectionPoints[pT]).cutTriangle1;            cutTriangle=(pairTriangleToIntersectionPoints[pairTriangle]).cutTriangle1;
1886          } else {          } else {
1887            cc=(pairTriangleToIntersectionPoints[pT]).cutTriangle2;            cutTriangle=(pairTriangleToIntersectionPoints[pairTriangle]).cutTriangle2;
1888          }          }
1889    
1890          for (size_t n=0; n<3; ++n) {          for (size_t n=0; n<3; ++n) {
1891            if(cc[n]!=0) {            if(cutTriangle[n]!=0) {
1892              tt[n]=1;              edgesCut[n]=1;
1893            }            }
1894          }          }
1895        }        }
# Line 1779  __determinateEdgeCut(const size_t& numob Line 1898  __determinateEdgeCut(const size_t& numob
1898        }        }
1899      }      }
1900    }    }
1901    return tt;    return edgesCut;
1902  }  }
1903    
1904  TinyVector<3,size_t>& SurfaceMeshGenerator::Internals::  TinyVector<3,size_t>& SurfaceMeshGenerator::Internals::
# Line 1787  __putEdgeRef(const size_t& ncase, Line 1906  __putEdgeRef(const size_t& ncase,
1906               const Triangle& currentTriangle,               const Triangle& currentTriangle,
1907               TriangleCut& K)               TriangleCut& K)
1908  {  {
1909    const TinyVector<3,TinyVector<2,int> >&  tt=K.edgecut;    const TinyVector<3,TinyVector<2,int> >&  cutTriangle=K.edgecut;
1910    TinyVector<3,size_t>& ii=K.isInTriangle;    TinyVector<3,size_t>& isIn=K.isInTriangle;
1911    size_t numobject=K.numobject;    size_t numobject=K.numobject;
1912    const Vertex* V0=&currentTriangle(0);    const Vertex* V0=&currentTriangle(0);
1913    const Vertex* V1=&currentTriangle(1);    const Vertex* V1=&currentTriangle(1);
1914    const Vertex* V2=&currentTriangle(2);    const Vertex* V2=&currentTriangle(2);
1915    
1916            
1917    if(tt[0][0]+tt[1][0]+tt[2][0]!=0 and ((*edgesRefVertex[numobject])[V0]+    if(cutTriangle[0][0]+cutTriangle[1][0]+cutTriangle[2][0]!=0 and ((*edgesRefVertex[numobject])[V0]+
1918                                          (*edgesRefVertex[numobject])[V1]+(*edgesRefVertex[numobject])[V2])==6) {                                          (*edgesRefVertex[numobject])[V1]+(*edgesRefVertex[numobject])[V2])==6) {
1919      ffout(0)<<"************************ ---------tr a pbs\n"<<std::flush;      ffout(0)<<"************************ ---------tr a pbs\n"<<std::flush;
1920      ffout(0)<<tt[0]<<" "<<tt[1]<<" "<<tt[2]<<"\n";      ffout(0)<<cutTriangle[0]<<" "<<cutTriangle[1]<<" "<<cutTriangle[2]<<"\n";
1921      ffout(0)<<*V0<<"\n";      ffout(0)<<*V0<<"\n";
1922      ffout(0)<<*V1<<"\n";      ffout(0)<<*V1<<"\n";
1923      ffout(0)<<*V2<<"\n";      ffout(0)<<*V2<<"\n";
1924    }    }
1925    
1926    __inout(numobject,tt[0][0],V0,V1);    __inout(numobject,cutTriangle[0][0],V0,V1);
1927    __inout(numobject,tt[1][0],V0,V2);    __inout(numobject,cutTriangle[1][0],V0,V2);
1928    __inout(numobject,tt[2][0],V1,V2);    __inout(numobject,cutTriangle[2][0],V1,V2);
1929    
1930    if(ncase==0) {    if(ncase==0) {
1931      if(tt[0][0]+tt[1][0]+tt[2][0]==0 and ((*edgesRefVertex[numobject])[V0]+      if(cutTriangle[0][0]+cutTriangle[1][0]+cutTriangle[2][0]==0 and ((*edgesRefVertex[numobject])[V0]+
1932                                            (*edgesRefVertex[numobject])[V1]+(*edgesRefVertex[numobject])[V2])>=4) {                                            (*edgesRefVertex[numobject])[V1]+(*edgesRefVertex[numobject])[V2])>=4) {
1933        (*edgesRefVertex[numobject])[V0]=2;        (*edgesRefVertex[numobject])[V0]=2;
1934        (*edgesRefVertex[numobject])[V1]=2;        (*edgesRefVertex[numobject])[V1]=2;
1935        (*edgesRefVertex[numobject])[V2]=2;        (*edgesRefVertex[numobject])[V2]=2;
1936      }        }  
1937    } else {    } else {
1938      // CECILE: s'agit-il d'un bug ? à quoi sert le deuxième ncase==0 ?      if(ncase==1) {
     // Si on arrive ici, on est sûr qu'il n'est pas vérifié  
     if(ncase==1 or ncase==0) {  
1939        for (size_t n=0; n<3; ++n) {        for (size_t n=0; n<3; ++n) {
1940          if((*edgesRefVertex[numobject])[&K(n)]==2 ) {          if((*edgesRefVertex[numobject])[&K(n)]==2 ) {
1941            ii[n]=1;            isIn[n]=1;
1942          } else {          } else {
1943            ii[n]=0;            isIn[n]=0;
1944          }          }
1945        }        }
1946      }      }
1947    }    }
1948    
1949    return ii;    return isIn;
1950  }  }
1951    
1952  void SurfaceMeshGenerator::Internals::  void SurfaceMeshGenerator::Internals::
1953  __createListTriangle(const TriangleCut& K,  __createListTriangle(const TriangleCut& K,
1954                       const Cell* cell)                       const Cell* cell)
1955  {  {
1956    const TinyVector<3,TinyVector<2,int> >&  tt=K.edgecut;    const TinyVector<3,TinyVector<2,int> >&  edgesCut=K.edgecut;
1957    const TinyVector<3,size_t>& ii=K.isInTriangle;    const TinyVector<3,size_t>& isIn=K.isInTriangle;
1958    const Vertex& V0=K(0);    const Vertex& V0=K(0);
1959    const Vertex& V1=K(1);    const Vertex& V1=K(1);
1960    const Vertex& V2=K(2);    const Vertex& V2=K(2);
1961        
1962    if(((tt[0][0]+tt[1][0]+tt[2][0]==0 and ii[0]+ii[1]+ii[2]==3) /*or ii[0]+ii[1]+ii[2]==3*/)) {    if(((edgesCut[0][0]+edgesCut[1][0]+edgesCut[2][0]==0 and isIn[0]+isIn[1]+isIn[2]==3) /*or isIn[0]+isIn[1]+isIn[2]==3*/)) {
1963      __addTriangle(V0,V1,V2,cell);      __addTriangle(V0,V1,V2,cell);
1964    } else {    } else {
1965      if(ii[0]+ii[1]+ii[2]==1) {      if(isIn[0]+isIn[1]+isIn[2]==1) {
1966        if(ii[0]==1) {        if(isIn[0]==1) {
1967          __createCase1(0,K,cell);          __createCase1(0,K,cell);
1968        }        }
1969        if(ii[1]==1) {        if(isIn[1]==1) {
1970          __createCase1(1,K,cell);          __createCase1(1,K,cell);
1971        }        }
1972        if(ii[2]==1) {        if(isIn[2]==1) {
1973          __createCase1(2,K,cell);          __createCase1(2,K,cell);
1974        }        }
1975      } else {      } else {
1976        if(ii[0]+ii[1]+ii[2]==2) {        if(isIn[0]+isIn[1]+isIn[2]==2) {
1977          if(ii[0]+ii[1]==2) {          if(isIn[0]+isIn[1]==2) {
1978            __createCase2(0,K,cell);            __createCase2(0,K,cell);
1979          }          }
1980          if(ii[0]+ii[2]==2) {          if(isIn[0]+isIn[2]==2) {
1981            __createCase2(1,K,cell);            __createCase2(1,K,cell);
1982          }          }
1983          if(ii[1]+ii[2]==2) {          if(isIn[1]+isIn[2]==2) {
1984            __createCase2(2,K,cell);            __createCase2(2,K,cell);
1985          }          }
1986        }        }
# Line 2264  __createTrianglesIntersection(const size Line 2381  __createTrianglesIntersection(const size
2381          if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==0 ) {          if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==0 ) {
2382            ++err2;            ++err2;
2383          }          }
2384          /*TinyVector<3> A(1.000000, -1.800000, -0.800000);          /*size_t test=0;
2385            TinyVector<3> B(1.000000 ,-1.800000 ,-1.200000);          TinyVector<3> A(-0.354585, -0.026316, -0.170374);
2386            TinyVector<3> C(1.000000 ,-1.600000 ,-1.000000 );            TinyVector<3> B(-0.210526, -0.039951, -0.210526);
2387              TinyVector<3> C(-0.210526, -0.026316, -0.195978);
2388            real_t ee=1e-5;            real_t ee=1e-5;
2389            if((Norm(V0.Vector3()-A)<=ee or Norm(V1.Vector3()-A)<=ee or Norm(V2.Vector3()-A)<=ee)            if((Norm(V0.Vector3()-A)<=ee or Norm(V1.Vector3()-A)<=ee or Norm(V2.Vector3()-A)<=ee)
2390            and (Norm(V0.Vector3()-B)<=ee or Norm(V1.Vector3()-B)<=ee or Norm(V2.Vector3()-B)<=ee)            and (Norm(V0.Vector3()-B)<=ee or Norm(V1.Vector3()-B)<=ee or Norm(V2.Vector3()-B)<=ee)
# Line 2280  __createTrianglesIntersection(const size Line 2398  __createTrianglesIntersection(const size
2398            ffout(0)<<vertexInTriangles.size()<<"\n";            ffout(0)<<vertexInTriangles.size()<<"\n";
2399            for(std::map<const Vertex*,TinyVector<2,const Triangle*> >::iterator            for(std::map<const Vertex*,TinyVector<2,const Triangle*> >::iterator
2400            it=vertexInTriangles.begin() ; it!=vertexInTriangles.end() ; ++it) {            it=vertexInTriangles.begin() ; it!=vertexInTriangles.end() ; ++it) {
2401            ffout(0)<<*(*it).first<<"\n";                ffout(0)<<*(*it).first<<"\n";
2402            }            }
2403              test=1;
2404            }*/            }*/
2405          if(K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2]==0          if(K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2]==0
2406             and K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==3 and vertexInTriangles.size()<3) {             and K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==3 and vertexInTriangles.size()<3) {
# Line 2408  __createTrianglesIntersection(const size Line 2527  __createTrianglesIntersection(const size
2527            if(K.pointsIntersection[0][0]!=K.pointsIntersection[1][0]            if(K.pointsIntersection[0][0]!=K.pointsIntersection[1][0]
2528               and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]               and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0]
2529               and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {               and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) {
2530              //ffout(0)<<"---------------- 3 edge cut \n";              ffout(0)<<"---------------- 3 edge cut \n";
2531              //ffout(0)<<V0<<"\n";              //ffout(0)<<V0<<"\n";
2532              //ffout(0)<<V1<<"\n";              //ffout(0)<<V1<<"\n";
2533              //ffout(0)<<V2<<"\n";              //ffout(0)<<V2<<"\n";
# Line 3216  generateSurfacicMesh(const Object& O, Line 3335  generateSurfacicMesh(const Object& O,
3335    size_t nb=nobjectToTreat;    size_t nb=nobjectToTreat;
3336    if(nb==0)    if(nb==0)
3337        nb=1;        nb=1;
   for (size_t numObj = 0; numObj<nb; ++numObj) {  
     // Data structure convertion  
     {  
 #warning keep this ?  
       size_t n=0;  
3338    
3339        ReferenceCounting<Vector<Vertex*> > pVertexList    (*__internals).__dataStructureConvertion(nb);
         = new Vector<Vertex*>((*(*__internals).verticesListes[numObj]).size());  
       (*__internals).listOfVertexList.push_back(pVertexList);  
       Vector<Vertex*>& vertexList = *pVertexList;  
   
       for (SurfaceMeshGenerator::Internals::VerticesList::iterator  
              i = (*(*__internals).verticesListes[numObj]).begin();  
            i != (*(*__internals).verticesListes[numObj]).end(); ++i, ++n) {  
         vertexList[n] = (*i).second;  
       }  
     }  
   
     {  
       size_t n=0;  
   
       ReferenceCounting<Vector<Triangle> > pTriangleList  
         = new Vector<Triangle> ((*(*__internals).triangleListes[numObj]).size());  
       (*__internals).listOfTriangleList.push_back(pTriangleList);  
       Vector<Triangle>& triangleList = *pTriangleList;  
   
       SurfaceMeshGenerator::Internals::MotherCellList::iterator  
         itcell=(*(*__internals).cellListObject[numObj]).begin();  
       for (SurfaceMeshGenerator::Internals::EdgePairList::iterator  
              i = (*(*__internals).triangleListes[numObj]).begin();  
            i != (*(*__internals).triangleListes [numObj]).end(); ++i, ++n) {  
         SurfaceMeshGenerator::Internals::VerticesList& V = (*(*__internals).verticesListes[numObj]);  
         Triangle T(* V[(*i)[0]],  
                    * V[(*i)[1]],  
                    * V[(*i)[2]], 1);  
   
 #warning Store mother cell here  
         T.setMother(*itcell);  
         triangleList[n] = T;  
         ++itcell;  
       }  
     }  
   
     //(*(*__internals).verticesListes[numObj]).clear();  
     (*(*__internals).triangleListes[numObj]).clear();  
   
     // Intersection lists  
   
     {  
 #warning keep this ?  
       size_t n=0;  
       ReferenceCounting<Vector<Vertex*> > pVertexListIntersection  
         = new Vector<Vertex*> ((*(*__internals).verticesListesIntersection[numObj]).size());  
       (*__internals).listOfVertexListIntersection.push_back(pVertexListIntersection);  
       Vector<Vertex*>& vertexListIntersection = *pVertexListIntersection;  
   
       //for not have double points  
       for (SurfaceMeshGenerator::Internals::VerticesList::iterator  
              i = (*(*__internals).verticesListesIntersection[numObj]).begin();  
            i != (*(*__internals).verticesListesIntersection[numObj]).end(); ++i, ++n) {  
         if ((*(*__internals).verticesListes[numObj]).find((*i).first)  
             !=(*(*__internals).verticesListes[numObj]).end()) {  
           //ffout(0)<<"point existe deja\n";  
           SurfaceMeshGenerator::Internals::VerticesList::iterator  
             j=(*(*__internals).verticesListes[numObj]).find((*i).first);  
           vertexListIntersection[n] = (*j).second;  
         } else {  
           vertexListIntersection[n] = (*i).second;  
           (*(*__internals).verticesListes[numObj])[(*i).first]  
             =(*i).second;                
         }  
       }  
     }  
     (*(*__internals).verticesListesIntersection[numObj]).clear();  
     {  
       size_t n=0;  
   
 #warning precompute this:  
       size_t size = 0;  
       for (SurfaceMeshGenerator::Internals::TriangleListesIntersectionEdgesPerHexa::iterator  
              i = (*__internals).triangleListesIntersectionEdgesPerHexa.begin();  
            i != (*__internals).triangleListesIntersectionEdgesPerHexa.end(); ++i) {  
         size += (*(*i).second[numObj]).size();  
       }  
   
       ReferenceCounting<Vector<Triangle> > pTriangleListIntersection  
         = new Vector<Triangle>(size);  
       (*__internals).listOfTriangleListIntersection.push_back(pTriangleListIntersection);  
       Vector<Triangle>& triangleListIntersection = *pTriangleListIntersection;  
   
       ReferenceCounting<std::map<const Cell*, std::list<Triangle*> > > pHexaToTriangle  
         = new std::map<const Cell*, std::list<Triangle*> >;  
       (*__internals).listOfHexaToTriangle.push_back(pHexaToTriangle);  
       std::map<const Cell*, std::list<Triangle*> >& hexaToTriangle = *pHexaToTriangle;  
   
       for (SurfaceMeshGenerator::Internals::TriangleListesIntersectionEdgesPerHexa::iterator  
              i = (*__internals).triangleListesIntersectionEdgesPerHexa.begin();  
            i != (*__internals).triangleListesIntersectionEdgesPerHexa.end(); ++i) {  
         for (SurfaceMeshGenerator::Internals::EdgePairList::iterator  
                j = (*(*i).second[numObj]).begin();  
              j !=  (*(*i).second[numObj]).end(); ++j) {  
           SurfaceMeshGenerator::Internals::VerticesList& V = (*(*__internals).verticesListes[numObj]);  
           Triangle T(* V[(*j)[0]],  
                      * V[(*j)[1]],  
                      * V[(*j)[2]], 1);  
               
           T.setMother((*i).first);  
   
           triangleListIntersection[n] = T;  
   
           hexaToTriangle[(*i).first].push_back(&triangleListIntersection[n]);  
           ++n;  
         }  
       }  
     }  
   
     (*(*__internals).verticesListes[numObj]).clear();  
   }  
   
   (*__internals).triangleListesIntersectionEdgesPerHexa.clear();  
3340    (*__internals).plotliste();    (*__internals).plotliste();
3341    
3342    size_t n0=0,n1=0;    size_t n0=0,n1=0;
3343    if(nobjectToTreat>1) {    if(nobjectToTreat>1) {
     //for(size_t ncompt=0 ; ncompt<=nobjectToTreat-5; ++ncompt) {  
3344      for(size_t ncompt=0 ; ncompt<=nobjectToTreat-2; ++ncompt) {      for(size_t ncompt=0 ; ncompt<=nobjectToTreat-2; ++ncompt) {
3345        //for(size_t ncompt=0 ; ncompt<=nobjectToTreat-2; ++ncompt) {
3346        ffout(0)<<"treat object "<<ncompt+1<<"\n"<<std::flush;        ffout(0)<<"treat object "<<ncompt+1<<"\n"<<std::flush;
3347        //calculate points intersection between object 0 and object 1        //calculate points intersection between object 0 and object 1
3348        (*__internals).__calculatePointsIntersection(scene,0,1);        (*__internals).__calculatePointsIntersection(scene,0,1);
       //  ffout(0)<<"end calculatePointsIntersection\n";  
3349        //create mesh intersection for the object 0 and 1        //create mesh intersection for the object 0 and 1
3350        (*__internals).__createTrianglesIntersection(0,1);        (*__internals).__createTrianglesIntersection(0,1);
3351        ffout(0)<<"nb triangles in intersection 0 "<<(*__internals).triangleListIntersectionNew.size()<<"\n"<<std::flush;        ffout(0)<<"nb triangles in intersection 0 "<<(*__internals).triangleListIntersectionNew.size()<<"\n"<<std::flush;
# Line 3353  generateSurfacicMesh(const Object& O, Line 3353  generateSurfacicMesh(const Object& O,
3353        ffout(0)<<"nb triangles in intersection 1 "<<(*__internals).triangleListIntersectionNew.size()<<"\n"<<std::flush;        ffout(0)<<"nb triangles in intersection 1 "<<(*__internals).triangleListIntersectionNew.size()<<"\n"<<std::flush;
3354    
3355        //erase triangles from object 0 and 1 and add triangle from intersection of objects 0-1        //erase triangles from object 0 and 1 and add triangle from intersection of objects 0-1
3356        SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator        (*__internals).__eraseAddTriangle(n0,n1);
3357          it=(*__internals).listOfTriangleListIntersection.begin();      }
       SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator  
         er=(*__internals).listOfTriangleListIntersection.erase(it);  
       it=(*__internals).listOfTriangleListIntersection.begin();  
       er=(*__internals).listOfTriangleListIntersection.erase(it);  
   
       size_t sizeinter=(*__internals).triangleListIntersectionNew.size();  
       ReferenceCounting<Vector<Triangle> > pTriangleListIntersection = new Vector<Triangle>(sizeinter);  
       (*__internals).listOfTriangleListIntersection.push_front(pTriangleListIntersection);  
       Vector<Triangle>& triangleListIntersection = *pTriangleListIntersection;  
   
       SurfaceMeshGenerator::Internals::ListOfHexaToTriangle::iterator  
         ithexa=(*__internals).listOfHexaToTriangle.begin();  
       SurfaceMeshGenerator::Internals::ListOfHexaToTriangle::iterator  
         erhexa=(*__internals).listOfHexaToTriangle.erase(ithexa);  
       ithexa=(*__internals).listOfHexaToTriangle.begin();  
       erhexa=(*__internals).listOfHexaToTriangle.erase(ithexa);  
       (*__internals).listOfHexaToTriangle.push_front(new std::map<const Cell*, std::list<Triangle*> >);  
       ithexa=(*__internals).listOfHexaToTriangle.begin();  
   
       for(size_t size=0 ; size<sizeinter ; ++size) {  
         triangleListIntersection[size]=(*__internals).triangleListIntersectionNew[size];  
         (*(*ithexa))[&triangleListIntersection[size].mother()].push_back(&triangleListIntersection[size]);  
       }  
       (*__internals).triangleListIntersectionNew.clear();  
   
       //copy meshes not intersected of object 0 and 1  
       ReferenceCounting<Vector<Triangle> > triangleListTemp;  
       size_t size=0;  
       SurfaceMeshGenerator::Internals::ListOfTriangleList::iterator  
         triangleit=(*__internals).listOfTriangleList.begin();  
       size+=(*(*triangleit)).size();  
       n0=size;  
       ++triangleit;  
       size+=(*(*triangleit)).size();  
       n1=size;  
       triangleListTemp=new Vector<Triangle>(size);  
       triangleit=(*__internals).listOfTriangleList.begin();  
       for(size_t s=0 ; s<(*(*triangleit)).size() ; ++s) {  
         (*triangleListTemp)[s]=(*(*triangleit))[s];  
       }  
       size_t numsize=(*(*triangleit)).size();  
       ++triangleit;  
       for(size_t s=0 ; s<(*(*triangleit)).size() ; ++s) {  
         (*triangleListTemp)[numsize+s]=(*(*triangleit))[s];  
       }  
   
       it=(*__internals).listOfTriangleList.begin();  
       er=(*__internals).listOfTriangleList.erase(it);  
       it=(*__internals).listOfTriangleList.begin();  
       er=(*__internals).listOfTriangleList.erase(it);  
       (*__internals).listOfTriangleList.push_front(new Vector<Triangle>(size));  
       it=(*__internals).listOfTriangleList.begin();  
       for(size_t s=0 ; s<(*triangleListTemp).size() ; ++s) {  
         (*(*it))[s]=(*triangleListTemp)[s];  
       }  
3358      }      }
   }  
3359    //end intersection mesh    //end intersection mesh
3360    
3361    //construction of list vertices    //construction of list vertices

Legend:
Removed from v.1.17  
changed lines
  Added in v.1.18

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