278 |
const Cell* cell, |
const Cell* cell, |
279 |
std::vector<Triangle>& triangleListIntersectionNew); |
std::vector<Triangle>& triangleListIntersectionNew); |
280 |
|
|
|
void __createCase1(int ncase, |
|
|
const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew); |
|
|
|
|
|
void __createCase2(int ncase, |
|
|
const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew); |
|
|
|
|
281 |
void __createLocalListIntersection(const size_t& objectNumber, |
void __createLocalListIntersection(const size_t& objectNumber, |
282 |
const ObjectToTreat& O2, |
const ObjectToTreat& O2, |
283 |
const Triangle*& currentTriangle, |
const Triangle*& currentTriangle, |
303 |
const Connectivity<Triangle>& connect, |
const Connectivity<Triangle>& connect, |
304 |
const std::set<const Cell*>& toTreatHexahedra); |
const std::set<const Cell*>& toTreatHexahedra); |
305 |
|
|
|
void __createListTriangle(const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew); |
|
|
|
|
306 |
void __createByEdges(const TriangleCut& K,const Cell* cell, |
void __createByEdges(const TriangleCut& K,const Cell* cell, |
307 |
std::vector<Triangle>& triangleListIntersectionNew); |
std::vector<Triangle>& triangleListIntersectionNew); |
308 |
|
|
1265 |
} |
} |
1266 |
|
|
1267 |
void SurfaceMeshGenerator::Internals:: |
void SurfaceMeshGenerator::Internals:: |
|
__createCase1(int ncase, |
|
|
const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew) |
|
|
{ |
|
|
//case 1 points is inside |
|
|
//ncase=number of the point which is inside |
|
|
const Vertex& V0=K(0); |
|
|
const Vertex& V1=K(1); |
|
|
const Vertex& V2=K(2); |
|
|
|
|
|
const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection; |
|
|
const std::map< const Vertex* ,const Vertex* >& pointsInterior=K.pointsin; |
|
|
const size_t& numberPointsInterior=pointsInterior.size(); |
|
|
const Vertex& A=K(ncase); |
|
|
|
|
|
TinyVector<3,int> edgesCut; |
|
|
TinyVector<3,int> vertexNum; |
|
|
|
|
|
__determinateCase(ncase,K,edgesCut,vertexNum); |
|
|
|
|
|
switch (numberPointsInterior) { |
|
|
case 0: { |
|
|
if(edgesCut[0]==1) { |
|
|
const Vertex& B=__determinateNumber(vertexNum[0],pointsIntersection); |
|
|
if(edgesCut[1]==1) { |
|
|
const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
if(B==C) { |
|
|
//cas ou les 2 points d'intersections sont de meme adresse (donc confondus) |
|
|
//ffout(4)<<"we have a problem createcase1\n"; |
|
|
//ffout(4)<<A<<&A<<"\n"; |
|
|
//ffout(4)<<B<<&B<<"\n"; |
|
|
//ffout(4)<<C<<&C<<"\n"; |
|
|
} else { |
|
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
} else { |
|
|
ffout(4) <<"pbs 10\n"<<std::flush; |
|
|
ffout(4)<<V0<<"\n"; |
|
|
ffout(4)<<V1<<"\n"; |
|
|
ffout(4)<<V2<<"\n"; |
|
|
ffout(4)<<edgesCut<<"\n"; |
|
|
} |
|
|
} else { |
|
|
if(edgesCut[1]==1) { |
|
|
ffout(4)<<"pbs 11\n"<<std::flush; |
|
|
ffout(4)<<V0<<"\n"; |
|
|
ffout(4)<<V1<<"\n"; |
|
|
ffout(4)<<V2<<"\n"; |
|
|
ffout(4)<<edgesCut<<"\n"; |
|
|
} else { |
|
|
// if(edgesCut==0) { |
|
|
// __addTriangle(Triangle(V0,V1,V2,K.reference()),cell,triangleListIntersectionNew); |
|
|
//} else { |
|
|
ffout(4) <<"pbs 111\n"; |
|
|
ffout(4)<<edgesCut<<"\n"; |
|
|
//} |
|
|
} |
|
|
} |
|
|
break; |
|
|
} |
|
|
default: { |
|
|
#warning is it true? case where only one edge is cut? |
|
|
ffout(4) << numberPointsInterior<<" be careful 1\n"<<std::flush; |
|
|
//case 1 point inside and more than 1 point in the triangle |
|
|
__createGeneral(K, cell, triangleListIntersectionNew); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
void SurfaceMeshGenerator::Internals:: |
|
|
__createCase2(int ncase, |
|
|
const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew) |
|
|
{ |
|
|
// case 2 points inside |
|
|
TinyVector<2,int> edgesCut; |
|
|
TinyVector<2,int> vertexNum; |
|
|
const Vertex& V0=K(0); |
|
|
const Vertex& V1=K(1); |
|
|
const Vertex& V2=K(2); |
|
|
|
|
|
const TinyVector<3,TinyVector<2,const Vertex*> >& pointsIntersection=K.pointsIntersection; |
|
|
const std::map<const Vertex* ,const Vertex*>& pointsInterior=K.pointsin; |
|
|
const TinyVector<3,TinyVector<2,int> >& edgesCut2=K.edgecut; |
|
|
const size_t& numberPointsInterior=pointsInterior.size(); |
|
|
|
|
|
size_t ncase0=0,ncase1=1; |
|
|
switch (ncase) { |
|
|
case 0: { |
|
|
edgesCut[0]=edgesCut2[1][0]; |
|
|
edgesCut[1]=edgesCut2[2][0]; |
|
|
vertexNum[0]=1; |
|
|
vertexNum[1]=2; |
|
|
break; |
|
|
} |
|
|
case 1: { |
|
|
edgesCut[0]=edgesCut2[0][0]; |
|
|
edgesCut[1]=edgesCut2[2][0]; |
|
|
vertexNum[0]=0; |
|
|
vertexNum[1]=2; |
|
|
ncase0=0; |
|
|
ncase1=2; |
|
|
break; |
|
|
} |
|
|
case 2: { |
|
|
edgesCut[0]=edgesCut2[0][0]; |
|
|
edgesCut[1]=edgesCut2[1][0]; |
|
|
vertexNum[0]=0; |
|
|
vertexNum[1]=1; |
|
|
ncase0=1; |
|
|
ncase1=2; |
|
|
} |
|
|
} |
|
|
|
|
|
const Vertex& A=K(ncase0); |
|
|
const Vertex& B=K(ncase1); |
|
|
|
|
|
switch (numberPointsInterior) { |
|
|
case 0: { |
|
|
if(edgesCut[0]==1) { |
|
|
const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection); |
|
|
if(edgesCut[1]==1) { |
|
|
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
//#warning Reference not set. |
|
|
if(D==C) { |
|
|
//si les 2 points d'inter sont confondus |
|
|
if(!(D==V0 or D==V1 or D==V2)) { |
|
|
//si le point d'inter n'est confondus avec aucun des sommets |
|
|
//ffout(4)<<"we have a problem\n"; |
|
|
//ffout(4)<<V0<<&V0<<"\n"; |
|
|
//ffout(4)<<V1<<&V1<<"\n"; |
|
|
//ffout(4)<<V2<<&V2<<"\n"; |
|
|
//ffout(4)<<A<<&A<<"\n"; |
|
|
//ffout(4)<<B<<&B<<"\n"; |
|
|
//ffout(4)<<C<<&C<<"\n"; |
|
|
// le triangle est vraisemblablement plat mais il le faut pour la connectivite du maillage |
|
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
} else { |
|
|
//il y a une point d'inter confondu avec un des sommets |
|
|
//il faut voir si ce n'est pas A ou B et dans ce cas on construit |
|
|
if(!(C==A or C==B)) { |
|
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
__addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
|
|
|
} else { |
|
|
ffout(4) <<"pbs 20\n"; |
|
|
//#warning Reference not set. |
|
|
//__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
} else { |
|
|
if(edgesCut[1]==1) { |
|
|
ffout(4) <<"pbs 210\n"; |
|
|
const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
//#warning Reference not set. |
|
|
//__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
} else { |
|
|
ffout(4) <<"pbs 21\n"<<std::flush; |
|
|
ffout(4)<<V0<<"\n"; |
|
|
ffout(4)<<V1<<"\n"; |
|
|
ffout(4)<<V2<<"\n"; |
|
|
ffout(4)<<edgesCut2<<"\n"; |
|
|
} |
|
|
} |
|
|
break; |
|
|
} |
|
|
case 1: { |
|
|
std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin(); |
|
|
const Vertex& E=*((*it).second); |
|
|
|
|
|
if(edgesCut[0]==1) { |
|
|
const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection); |
|
|
if(edgesCut[1]==1) { |
|
|
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
//#warning Reference not set. |
|
|
__addTriangle(Triangle(A,C,E,K.reference()),cell,triangleListIntersectionNew); |
|
|
__addTriangle(Triangle(A,E,B,K.reference()),cell,triangleListIntersectionNew); |
|
|
__addTriangle(Triangle(B,E,D,K.reference()),cell,triangleListIntersectionNew); |
|
|
} else { |
|
|
__addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew); |
|
|
__addTriangle(Triangle(C,E,B,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
} else { |
|
|
if(edgesCut[1]==1) { |
|
|
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
//#warning Reference not set. |
|
|
__addTriangle(Triangle(D,E,B,K.reference()),cell,triangleListIntersectionNew); |
|
|
__addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew); |
|
|
} else { |
|
|
__addTriangle(Triangle(A,B,E,K.reference()),cell,triangleListIntersectionNew); |
|
|
} |
|
|
} |
|
|
break; |
|
|
} |
|
|
default: { |
|
|
//POUR STEPH : peut generer des tr plats |
|
|
ffout(4) << numberPointsInterior <<"be careful 2\n"<<std::flush; |
|
|
// ffout(4)<<V0<<"\n"; |
|
|
// ffout(4)<<V1<<"\n"; |
|
|
// ffout(4)<<V2<<"\n"; |
|
|
// TinyVector<10,const Vertex*> P,Ptemp; |
|
|
// size_t i=0; |
|
|
// for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin(); |
|
|
// it!=pointsInterior.end() ; ++it) { |
|
|
// P[i+1]=(*it).second; |
|
|
// ++i; |
|
|
// } |
|
|
|
|
|
// CECILE: les deux 'if' qui suivent en sont-ils vraiment ou |
|
|
// veux-tu vérifier simplement que l'assertion est vérifiée ? |
|
|
// Dans ce cas, il serait bien préférable d'utiliser assert() |
|
|
|
|
|
// if(edgesCut[0]==1) { |
|
|
// const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection); |
|
|
// __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
|
|
// P[0]=&C; |
|
|
// if(edgesCut[1]==1) { |
|
|
// const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
|
|
// size_t size=numberPointsInterior+1; |
|
|
// for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) { |
|
|
// size_t num=1; |
|
|
// real_t norm=Norm((*P[0])-(*P[1])); |
|
|
// for(size_t i=2 ; i<size ; ++i) { |
|
|
// real_t normtemp=Norm((*P[0])-(*P[i])); |
|
|
// if(normtemp<=norm) { |
|
|
// norm=normtemp; |
|
|
// Ptemp[i-1]=P[num]; |
|
|
// num=i; |
|
|
// } else { |
|
|
// Ptemp[i-1]=P[i]; |
|
|
// } |
|
|
// } |
|
|
//#warning Reference not set. |
|
|
// __addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew); |
|
|
// Ptemp[0]=P[num]; |
|
|
// P=Ptemp; |
|
|
// --size; |
|
|
// // ffout(4)<<"size = "<<size<<"\n"; |
|
|
// } |
|
|
//#warning Reference not set. |
|
|
// __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
|
|
// __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew); |
|
|
// //__addTriangle(A,B,D,cell); |
|
|
// } else { |
|
|
// ffout(4)<<"une seule arete cut pbs\n"; |
|
|
// } |
|
|
// } else { |
|
|
// ffout(4)<<"une seule arete cut pbs2\n"; |
|
|
// } |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
void SurfaceMeshGenerator::Internals:: |
|
1268 |
__createLocalListIntersection(const size_t& objectNumber, |
__createLocalListIntersection(const size_t& objectNumber, |
1269 |
const ObjectToTreat& O2, |
const ObjectToTreat& O2, |
1270 |
const Triangle*& currentTriangle, |
const Triangle*& currentTriangle, |
1315 |
const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0]; |
const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0]; |
1316 |
const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1]; |
const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1]; |
1317 |
const Triangle T=(*(*jt0)); |
const Triangle T=(*(*jt0)); |
|
real_t epsilon=1e-6; |
|
1318 |
if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2)) |
if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2)) |
1319 |
and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) { |
and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) { |
1320 |
//ffout(4)<<"inter confondu avec arete\n"; |
//ffout(4)<<"inter confondu avec arete\n"; |
1321 |
isDegenerate=1; |
isDegenerate=0; |
1322 |
} |
} |
1323 |
} |
} |
1324 |
if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) { |
if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) { |
1325 |
for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) { |
for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) { |
1326 |
const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b]; |
const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b]; |
1327 |
const Triangle T=(*(*jt0)); |
const Triangle T=(*(*jt0)); |
1328 |
real_t epsilon=1e-6; |
// si on a le point est confondu avec un sommet on n'a pas besoin du triangle pour la connectivite |
1329 |
if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) |
if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) |
1330 |
or b==0) { |
/*or b==0*/) { |
1331 |
if(vertexInTriangles.find(V)==vertexInTriangles.end()) { |
if(vertexInTriangles.find(V)==vertexInTriangles.end()) { |
1332 |
TinyVector<2,const Triangle*> triangles; |
TinyVector<2,const Triangle*> triangles; |
1333 |
triangles[0]=*jt0; |
triangles[0]=*jt0; |
1694 |
} |
} |
1695 |
|
|
1696 |
void SurfaceMeshGenerator::Internals:: |
void SurfaceMeshGenerator::Internals:: |
|
__createListTriangle(const TriangleCut& K, |
|
|
const Cell* cell, |
|
|
std::vector<Triangle>& triangleListIntersectionNew) |
|
|
{ |
|
|
//create triangles "include" in the triangle K |
|
|
const TinyVector<3,TinyVector<2,int> >& edgesCut=K.edgecut; |
|
|
const TinyVector<3,size_t>& isIn=K.isInTriangle; |
|
|
const Vertex& V0=K(0); |
|
|
const Vertex& V1=K(1); |
|
|
const Vertex& V2=K(2); |
|
|
|
|
|
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*/)) { |
|
|
//#warning Reference not set. |
|
|
__addTriangle(Triangle(V0,V1,V2,K.reference()),cell,triangleListIntersectionNew); |
|
|
} else { |
|
|
if(isIn[0]+isIn[1]+isIn[2]==1) { |
|
|
if(isIn[0]==1) { |
|
|
__createCase1(0,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
if(isIn[1]==1) { |
|
|
__createCase1(1,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
if(isIn[2]==1) { |
|
|
__createCase1(2,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
} else { |
|
|
if(isIn[0]+isIn[1]+isIn[2]==2) { |
|
|
if(isIn[0]+isIn[1]==2) { |
|
|
__createCase2(0,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
if(isIn[0]+isIn[2]==2) { |
|
|
__createCase2(1,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
if(isIn[1]+isIn[2]==2) { |
|
|
__createCase2(2,K,cell,triangleListIntersectionNew); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
void SurfaceMeshGenerator::Internals:: |
|
1697 |
__createGeneral(const TriangleCut& K,const Cell* cell, |
__createGeneral(const TriangleCut& K,const Cell* cell, |
1698 |
std::vector<Triangle>& triangleListIntersectionNew) |
std::vector<Triangle>& triangleListIntersectionNew) |
1699 |
{ |
{ |
1700 |
//Initialisation pour l'instant on suppose un point in |
// pour l'instant on suppose edge cut une seule fois |
1701 |
size_t iCut=0, iInter=0, stop=0,in=0; |
size_t iCut=0, iInter=0, stop=0,in=0,in1=0; |
1702 |
size_t nbInter=triangleWithVertex.size(); |
size_t nbInter=triangleWithVertex.size(); |
1703 |
size_t nbCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]; |
size_t nbCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]; |
1704 |
TinyVector<2,const Vertex*> P; |
TinyVector<2,const Vertex*> P; |
1705 |
TinyVector<2,const Triangle*> T; |
TinyVector<2,const Triangle*> T; |
1706 |
TinyVector<3,size_t> place; |
TinyVector<3,size_t> place; |
1707 |
if(K.isInTriangle[1]==1) { |
size_t numberIn=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2]; |
1708 |
in=1; |
switch (numberIn) { |
1709 |
place[0]=2; |
case 1: { |
1710 |
place[1]=0; |
if(K.isInTriangle[1]==1) { |
1711 |
place[2]=1; |
in=1; |
1712 |
} else if(K.isInTriangle[2]==1) { |
place[0]=2; |
1713 |
in=2; |
place[1]=0; |
1714 |
place[0]=1; |
place[2]=1; |
1715 |
place[1]=2; |
} else if(K.isInTriangle[2]==1) { |
1716 |
place[2]=0; |
in=2; |
1717 |
} else { |
place[0]=1; |
1718 |
place[0]=0; |
place[1]=2; |
1719 |
place[1]=1; |
place[2]=0; |
1720 |
place[2]=2; |
} else { |
1721 |
|
place[0]=0; |
1722 |
|
place[1]=1; |
1723 |
|
place[2]=2; |
1724 |
|
} |
1725 |
|
break; |
1726 |
|
} |
1727 |
|
case 2: { |
1728 |
|
if(K.isInTriangle[1]==1 and K.isInTriangle[0]==1) { |
1729 |
|
in=1; |
1730 |
|
in1=0; |
1731 |
|
place[0]=1; |
1732 |
|
place[1]=2; |
1733 |
|
place[2]=0; |
1734 |
|
} else if(K.isInTriangle[2]==1 and K.isInTriangle[1]==1) { |
1735 |
|
in=2; |
1736 |
|
in1=1; |
1737 |
|
place[0]=0; |
1738 |
|
place[1]=1; |
1739 |
|
place[2]=2; |
1740 |
|
} else { |
1741 |
|
in=0; |
1742 |
|
in1=2; |
1743 |
|
place[0]=2; |
1744 |
|
place[1]=0; |
1745 |
|
place[2]=1; |
1746 |
|
} |
1747 |
|
break; |
1748 |
|
} |
1749 |
} |
} |
1750 |
const Vertex* A=&K(in); |
const Vertex* A=&K(in); |
1751 |
P[0]=K.pointsIntersection[place[0]][0]; |
P[0]=K.pointsIntersection[place[0]][0]; |
1756 |
stop=1; |
stop=1; |
1757 |
ffout(4)<<"pbs 0 existe pas\n"; |
ffout(4)<<"pbs 0 existe pas\n"; |
1758 |
} |
} |
1759 |
|
if(numberIn==2 and stop==0) { |
1760 |
|
__addTriangle(Triangle(K(in1),*A,*P[0],K.reference()),cell,triangleListIntersectionNew); |
1761 |
|
} |
1762 |
//iInter=1; |
//iInter=1; |
1763 |
while(iInter<nbInter and stop==0) { |
while(iInter<nbInter and stop==0) { |
1764 |
ffout(4)<<"createGeneral "<<iInter<<" "<<nbInter<<"\n"; |
//ffout(4)<<"createGeneral "<<iInter<<" "<<nbInter<<"\n"; |
1765 |
//on cherche le voisin de Pi |
//on cherche le voisin de Pi |
1766 |
if(triangleWithVertex.find(T[0])!=triangleWithVertex.end()) { |
if(triangleWithVertex.find(T[0])!=triangleWithVertex.end()) { |
1767 |
TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[0])).second; |
TinyVector<2,const Vertex*> VV=(*triangleWithVertex.find(T[0])).second; |
1770 |
//on est a priori sur une arete |
//on est a priori sur une arete |
1771 |
if(iCut<nbCut) { |
if(iCut<nbCut) { |
1772 |
#warning CAS edge cut twice |
#warning CAS edge cut twice |
1773 |
|
//ffout(4)<<"cas 1\n"; |
1774 |
P[1]=K.pointsIntersection[place[iCut]][0]; |
P[1]=K.pointsIntersection[place[iCut]][0]; |
|
if(nbInter==2) { |
|
|
ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n"; |
|
|
} |
|
1775 |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
1776 |
P[0]=P[1]; |
P[0]=P[1]; |
1777 |
++iInter; |
++iInter; |
1781 |
ffout(4)<<"on s'arrete en plein milieu\n"; |
ffout(4)<<"on s'arrete en plein milieu\n"; |
1782 |
} |
} |
1783 |
} else { |
} else { |
1784 |
|
//ffout(4)<<"cas 2\n"; |
1785 |
P[1]=VV[1]; |
P[1]=VV[1]; |
|
if(nbInter==2) { |
|
|
ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n"; |
|
|
} |
|
1786 |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
1787 |
P[0]=P[1]; |
P[0]=P[1]; |
1788 |
++iInter; |
++iInter; |
1789 |
} |
} |
1790 |
} else { |
} else { |
1791 |
|
//ffout(4)<<"cas 3\n"; |
1792 |
P[1]=VV[0]; |
P[1]=VV[0]; |
|
if(nbInter==2) { |
|
|
ffout(4)<<A<<" "<<P[0]<<" "<<P[1]<<"\n"; |
|
|
} |
|
1793 |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
1794 |
P[0]=P[1]; |
P[0]=P[1]; |
1795 |
++iInter; |
++iInter; |
1809 |
} |
} |
1810 |
if(T2[0]==T[0]) { |
if(T2[0]==T[0]) { |
1811 |
if(T2[1]==T[0]) { |
if(T2[1]==T[0]) { |
1812 |
stop=1; |
++iCut; |
1813 |
ffout(4)<<"pbs triangle\n"; |
if(iCut<nbCut) { |
1814 |
|
#warning CAS edge cut twice |
1815 |
|
ffout(4)<<iCut<<" cas new\n"; |
1816 |
|
if(P[0]==K.pointsIntersection[place[iCut]][0]) { |
1817 |
|
ffout(4)<<"j'ai le point1\n"; |
1818 |
|
--iCut; |
1819 |
|
} |
1820 |
|
if(P[0]==K.pointsIntersection[place[1]][0]) { |
1821 |
|
ffout(4)<<"j'ai le point2\n"; |
1822 |
|
--iCut; |
1823 |
|
} |
1824 |
|
if(P[0]==K.pointsIntersection[place[0]][0]) { |
1825 |
|
ffout(4)<<"j'ai le point3\n"; |
1826 |
|
--iCut; |
1827 |
|
} |
1828 |
|
|
1829 |
|
|
1830 |
|
//P[1]=K.pointsIntersection[place[iCut]][0]; |
1831 |
|
//__addTriangle(Triangle(*A,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
1832 |
|
//P[0]=P[1]; |
1833 |
|
//++iInter; |
1834 |
|
//++iCut; |
1835 |
|
} else { |
1836 |
|
stop=1; |
1837 |
|
ffout(4)<<"nbCut icut "<<iCut<<" "<<nbCut<<"\n"; |
1838 |
|
ffout(4)<<"pbs triangle\n"; |
1839 |
|
} |
1840 |
|
|
1841 |
} else { |
} else { |
1842 |
T[0]=T2[1]; |
T[0]=T2[1]; |
1843 |
} |
} |
2291 |
vertexInTriangles.clear(); |
vertexInTriangles.clear(); |
2292 |
|
|
2293 |
__createLocalListIntersection(objectNumber,O2,T,K,*i); |
__createLocalListIntersection(objectNumber,O2,T,K,*i); |
2294 |
|
std::map< const Vertex* ,const Vertex*> pointsin=K.pointsin; |
2295 |
|
size_t numberP=pointsin.size(); |
2296 |
|
|
2297 |
const Vertex* P0=(*listOfVertexMesh.find(&K(0))).second; |
const Vertex* P0=(*listOfVertexMesh.find(&K(0))).second; |
2298 |
const Vertex* P1=(*listOfVertexMesh.find(&K(1))).second; |
const Vertex* P1=(*listOfVertexMesh.find(&K(1))).second; |
2334 |
} else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) { |
} else if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]!=0) { |
2335 |
if(vertexInTriangles.size()==3) { |
if(vertexInTriangles.size()==3) { |
2336 |
//there are 3 points intersection so we create a triangle |
//there are 3 points intersection so we create a triangle |
2337 |
__3pointsintersection(K,*i,triangleListIntersectionNew); |
//__3pointsintersection(K,*i,triangleListIntersectionNew); |
2338 |
} else { |
} else { |
2339 |
size_t numberEdgesCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]; |
size_t numberEdgesCut=K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]; |
2340 |
if(vertexInTriangles.size()>3 and numberEdgesCut==1){ |
if(vertexInTriangles.size()>3 and numberEdgesCut==1){ |
2341 |
//one edge cut but twice |
//one edge cut but twice |
2342 |
ffout(4)<<"createNotIn\n"; |
ffout(4)<<"createNotIn\n"; |
2343 |
//POUR STEPH : createNotIn peut generer des tr plats |
//POUR STEPH : createNotIn peut generer des tr plats |
2344 |
__createNotIn(K,*i, triangleListIntersectionNew); |
//__createNotIn(K,*i, triangleListIntersectionNew); |
2345 |
} else { |
} else { |
2346 |
if(vertexInTriangles.size()>3 and numberEdgesCut==2) { |
if(vertexInTriangles.size()>3 and numberEdgesCut==2) { |
2347 |
//two edge cut but twice |
//two edge cut but twice |
2436 |
and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0] |
and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0] |
2437 |
and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) { |
and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) { |
2438 |
ffout(4)<<"---------------- 3 edge cut \n"; |
ffout(4)<<"---------------- 3 edge cut \n"; |
2439 |
__createByEdges(K,*i,triangleListIntersectionNew); |
//__createGeneral(K,*i,triangleListIntersectionNew); |
2440 |
} else { |
} else { |
2441 |
__createListTriangle(K,*i,triangleListIntersectionNew); |
if(numberP<=2) { |
2442 |
|
__createGeneral(K, *i, triangleListIntersectionNew); |
2443 |
|
} else { |
2444 |
|
ffout(4)<<"numberP "<<numberP<<"\n"; |
2445 |
|
} |
2446 |
} |
} |
2447 |
} else { |
} else { |
2448 |
__createListTriangle(K,*i,triangleListIntersectionNew); |
if(numberP<=2) { |
2449 |
|
__createGeneral(K, *i, triangleListIntersectionNew); |
2450 |
|
} else { |
2451 |
|
ffout(4)<<"numberP "<<numberP<<"\n"; |
2452 |
|
} |
2453 |
} |
} |
2454 |
break; |
break; |
2455 |
} |
} |
2457 |
if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) { |
if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) { |
2458 |
ffout(4)<<"case 2 pas traite \n"; |
ffout(4)<<"case 2 pas traite \n"; |
2459 |
} else { |
} else { |
2460 |
__createListTriangle(K,*i,triangleListIntersectionNew); |
if(numberP<=2) { |
2461 |
|
__createGeneral(K, *i, triangleListIntersectionNew); |
2462 |
|
} else { |
2463 |
|
ffout(4)<<"numberP "<<numberP<<"\n"; |
2464 |
|
} |
2465 |
} |
} |
2466 |
break; |
break; |
2467 |
} |
} |
3237 |
(*__internals).__constructionFinalMesh((*objectStack.top()), |
(*__internals).__constructionFinalMesh((*objectStack.top()), |
3238 |
s_mesh); |
s_mesh); |
3239 |
|
|
3240 |
#warning _________________________________A ENLEVER_________ |
/* #warning _________________________________A ENLEVER_________ |
3241 |
Connectivity<Triangle> connect(s_mesh.numberOfCells()); |
Connectivity<Triangle> connect(s_mesh.numberOfCells()); |
3242 |
ConnectivityBuilder<SurfaceMeshOfTriangles> C(s_mesh,connect); |
ConnectivityBuilder<SurfaceMeshOfTriangles> C(s_mesh,connect); |
3243 |
size_t compt=0; |
size_t compt=0; |
3251 |
} |
} |
3252 |
} |
} |
3253 |
} |
} |
3254 |
ffout(4)<<"****************************il manque "<<compt<<" sommets\n"; |
ffout(4)<<"****************************il manque "<<compt<<" sommets\n";*/ |
3255 |
///////////////////////////////////////////////////////////////////////////// |
///////////////////////////////////////////////////////////////////////////// |
3256 |
|
|
3257 |
int n0=0, n1=0; |
int n0=0, n1=0; |