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, |
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, |
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; |
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; |
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 { |
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) { |
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 |
} |
} |
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 |
} |
} |
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 |
} |
} |
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; |
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"; |
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 { |
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; |
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 |
} |
} |
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 |
} |
} |
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 { |
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; |
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); |
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 { |
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 |
} |
} |
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) { |
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(); |
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; |
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 |
} |
} |
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 |
} |
} |
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: |
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 { |
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; |
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 |
} |
} |
1898 |
} |
} |
1899 |
} |
} |
1900 |
} |
} |
1901 |
return tt; |
return edgesCut; |
1902 |
} |
} |
1903 |
|
|
1904 |
TinyVector<3,size_t>& SurfaceMeshGenerator::Internals:: |
TinyVector<3,size_t>& SurfaceMeshGenerator::Internals:: |
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=¤tTriangle(0); |
const Vertex* V0=¤tTriangle(0); |
1913 |
const Vertex* V1=¤tTriangle(1); |
const Vertex* V1=¤tTriangle(1); |
1914 |
const Vertex* V2=¤tTriangle(2); |
const Vertex* V2=¤tTriangle(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 |
} |
} |
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) |
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) { |
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"; |
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; |
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 |