1017 |
real_t inV12=Norm(V12^V1P); |
real_t inV12=Norm(V12^V1P); |
1018 |
real_t inV02=Norm(V02^V2P); |
real_t inV02=Norm(V02^V2P); |
1019 |
|
|
1020 |
if(/*norm2>epsilon and norm3>epsilon and*/ std::abs((norm2+norm3)-norm1) < epsilon ) { |
if(/*norm2>epsilon and norm3>epsilon and */std::abs((norm2+norm3)-norm1) < epsilon ) { |
1021 |
if(ncase<3) { |
if(ncase<3) { |
1022 |
__InTriangle(P,V,num); |
__InTriangle(P,V,num); |
1023 |
if(num==3) { |
if(num==3) { |
1024 |
// if(!(norm2>epsilon)) { |
if(!(norm2>epsilon)) { |
1025 |
// Pinter.addPoint(Vo0); |
Pinter.addPoint(Vo0); |
1026 |
// } else |
} else |
1027 |
// if(!(norm3>epsilon)) { |
if(!(norm3>epsilon)) { |
1028 |
// Pinter.addPoint(Vo1); |
Pinter.addPoint(Vo1); |
1029 |
// } else |
} else |
1030 |
if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end() |
if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end() |
1031 |
and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) { |
and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) { |
1032 |
listVertexIntersectionNew[pV][0]=new Vertex (P); |
listVertexIntersectionNew[pV][0]=new Vertex (P); |
1066 |
//ffout(4)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n"; |
//ffout(4)<<P[0]<<" "<<P[1]<<" "<<P[2]<<" \n"; |
1067 |
//listVertexIntersectionNew.push_back(new Vertex (P)); |
//listVertexIntersectionNew.push_back(new Vertex (P)); |
1068 |
PIntersection PIn; |
PIntersection PIn; |
1069 |
// if(!(norm2>epsilon)) { |
if(!(norm2>epsilon)) { |
1070 |
// Pinter.addPoint(Vo0); |
Pinter.addPoint(Vo0); |
1071 |
// } else { |
} else { |
1072 |
// if(!(norm3>epsilon)) { |
if(!(norm3>epsilon)) { |
1073 |
// Pinter.addPoint(Vo1); |
Pinter.addPoint(Vo1); |
1074 |
// } else |
} else |
1075 |
{ |
{ |
1076 |
if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end() |
if(listVertexIntersectionNew.find(pV)==listVertexIntersectionNew.end() |
1077 |
and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) { |
and listVertexIntersectionNew.find(pV2)==listVertexIntersectionNew.end()) { |
1108 |
} |
} |
1109 |
} |
} |
1110 |
} |
} |
1111 |
// } |
} |
1112 |
// Pinter.addPoint(listVertexIntersectionNew[listVertexIntersectionNew.size()-1]); |
// Pinter.addPoint(listVertexIntersectionNew[listVertexIntersectionNew.size()-1]); |
1113 |
} |
} |
1114 |
} |
} |
1216 |
real_t norm1=Norm(P-Vo1); |
real_t norm1=Norm(P-Vo1); |
1217 |
real_t norm2=Norm(P-Vo2); |
real_t norm2=Norm(P-Vo2); |
1218 |
//for filter points |
//for filter points |
1219 |
//real_t eps=1e-10; |
real_t eps=1e-6; |
1220 |
if(/*norm0>eps and norm1>eps and*/ std::abs((norm0+norm1)-Vo01)<epsilon) { |
if(/*norm0>eps and norm1>eps and */std::abs((norm0+norm1)-Vo01)<epsilon) { |
1221 |
cutTr2[0]=i+1; |
cutTr2[0]=i+1; |
1222 |
} |
} |
1223 |
if(/*norm0>eps and norm2>eps and */std::abs((norm0+norm2)-Vo02)<epsilon) { |
if(/*norm0>eps and norm2>eps and */std::abs((norm0+norm2)-Vo02)<epsilon) { |
1252 |
if(!__isDegenerate(T)) { |
if(!__isDegenerate(T)) { |
1253 |
triangleListIntersectionNew.push_back(T); |
triangleListIntersectionNew.push_back(T); |
1254 |
} else { |
} else { |
1255 |
fferr(4) << "\t\tTriangle dégénéré :" |
fferr(3) << "\t\tTriangle dégénéré :" |
1256 |
<< &T(0) << ':' << &T(1) << ':' << &T(2) << '\n'; |
<< &T(0) << ':' << &T(1) << ':' << &T(2) << '\n'; |
1257 |
triangleListIntersectionNew.push_back(T); |
fferr(3) |
1258 |
|
<< T(0) << ':' << T(1) << ':' << T(2) << '\n'; |
1259 |
|
// triangleListIntersectionNew.push_back(T); |
1260 |
} |
} |
1261 |
} |
} |
1262 |
|
|
1449 |
if(edgesCut[1]==1) { |
if(edgesCut[1]==1) { |
1450 |
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
1451 |
//#warning Reference not set. |
//#warning Reference not set. |
1452 |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
if(D==C) { |
1453 |
__addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew); |
if(!(D==K(0) or D==K(1) or D==K(2))) { |
1454 |
|
if(Norm(D-K(0))<1e-6 or Norm(D-K(1))<1e-6 or Norm(D-K(2))<1e-6) { |
1455 |
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1456 |
|
} else { |
1457 |
|
ffout(4)<<"we have a problem\n"; |
1458 |
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1459 |
|
__addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew); |
1460 |
|
} |
1461 |
|
} else { |
1462 |
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1463 |
|
} |
1464 |
|
} else { |
1465 |
|
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1466 |
|
__addTriangle(Triangle(C,B,D,K.reference()),cell,triangleListIntersectionNew); |
1467 |
|
} |
1468 |
} else { |
} else { |
1469 |
// ffout(4) <<"pbs 20\n"; |
ffout(4) <<"pbs 20\n"; |
1470 |
//#warning Reference not set. |
//#warning Reference not set. |
1471 |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1472 |
} |
} |
1473 |
} else { |
} else { |
1474 |
if(edgesCut[1]==1) { |
if(edgesCut[1]==1) { |
1475 |
// ffout(4) <<"pbs 210\n"; |
ffout(4) <<"pbs 210\n"; |
1476 |
const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection); |
const Vertex& C=__determinateNumber(vertexNum[1],pointsIntersection); |
1477 |
//#warning Reference not set. |
//#warning Reference not set. |
1478 |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1520 |
// ffout(4)<<V0<<"\n"; |
// ffout(4)<<V0<<"\n"; |
1521 |
// ffout(4)<<V1<<"\n"; |
// ffout(4)<<V1<<"\n"; |
1522 |
// ffout(4)<<V2<<"\n"; |
// ffout(4)<<V2<<"\n"; |
1523 |
TinyVector<10,const Vertex*> P,Ptemp; |
// TinyVector<10,const Vertex*> P,Ptemp; |
1524 |
size_t i=0; |
// size_t i=0; |
1525 |
for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin(); |
// for(std::map<const Vertex*,const Vertex*>::const_iterator it=pointsInterior.begin(); |
1526 |
it!=pointsInterior.end() ; ++it) { |
// it!=pointsInterior.end() ; ++it) { |
1527 |
P[i+1]=(*it).second; |
// P[i+1]=(*it).second; |
1528 |
++i; |
// ++i; |
1529 |
} |
// } |
1530 |
|
|
1531 |
// CECILE: les deux 'if' qui suivent en sont-ils vraiment ou |
// CECILE: les deux 'if' qui suivent en sont-ils vraiment ou |
1532 |
// veux-tu vérifier simplement que l'assertion est vérifiée ? |
// veux-tu vérifier simplement que l'assertion est vérifiée ? |
1533 |
// Dans ce cas, il serait bien préférable d'utiliser assert() |
// Dans ce cas, il serait bien préférable d'utiliser assert() |
1534 |
|
|
1535 |
if(edgesCut[0]==1) { |
// if(edgesCut[0]==1) { |
1536 |
const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection); |
// const Vertex& C=__determinateNumber(vertexNum[0],pointsIntersection); |
1537 |
__addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
// __addTriangle(Triangle(A,B,C,K.reference()),cell,triangleListIntersectionNew); |
1538 |
P[0]=&C; |
// P[0]=&C; |
1539 |
if(edgesCut[1]==1) { |
// if(edgesCut[1]==1) { |
1540 |
const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
// const Vertex& D=__determinateNumber(vertexNum[1],pointsIntersection); |
1541 |
size_t size=numberPointsInterior+1; |
// size_t size=numberPointsInterior+1; |
1542 |
for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) { |
// for(size_t boucle=0 ; boucle<numberPointsInterior-1 ; ++boucle) { |
1543 |
size_t num=1; |
// size_t num=1; |
1544 |
real_t norm=Norm((*P[0])-(*P[1])); |
// real_t norm=Norm((*P[0])-(*P[1])); |
1545 |
for(size_t i=2 ; i<size ; ++i) { |
// for(size_t i=2 ; i<size ; ++i) { |
1546 |
real_t normtemp=Norm((*P[0])-(*P[i])); |
// real_t normtemp=Norm((*P[0])-(*P[i])); |
1547 |
if(normtemp<=norm) { |
// if(normtemp<=norm) { |
1548 |
norm=normtemp; |
// norm=normtemp; |
1549 |
Ptemp[i-1]=P[num]; |
// Ptemp[i-1]=P[num]; |
1550 |
num=i; |
// num=i; |
1551 |
} else { |
// } else { |
1552 |
Ptemp[i-1]=P[i]; |
// Ptemp[i-1]=P[i]; |
1553 |
} |
// } |
1554 |
} |
// } |
1555 |
//#warning Reference not set. |
//#warning Reference not set. |
1556 |
__addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew); |
// __addTriangle(Triangle(B,*P[0],*P[num],K.reference()),cell,triangleListIntersectionNew); |
1557 |
Ptemp[0]=P[num]; |
// Ptemp[0]=P[num]; |
1558 |
P=Ptemp; |
// P=Ptemp; |
1559 |
--size; |
// --size; |
1560 |
// ffout(4)<<"size = "<<size<<"\n"; |
// // ffout(4)<<"size = "<<size<<"\n"; |
1561 |
} |
// } |
1562 |
//#warning Reference not set. |
//#warning Reference not set. |
1563 |
__addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
// __addTriangle(Triangle(B,*P[0],*P[1],K.reference()),cell,triangleListIntersectionNew); |
1564 |
__addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew); |
// __addTriangle(Triangle(B,*P[1],D,K.reference()),cell,triangleListIntersectionNew); |
1565 |
//__addTriangle(A,B,D,cell); |
// //__addTriangle(A,B,D,cell); |
1566 |
} else { |
// } else { |
1567 |
ffout(4)<<"une seule arete cut pbs\n"; |
// ffout(4)<<"une seule arete cut pbs\n"; |
1568 |
} |
// } |
1569 |
} else { |
// } else { |
1570 |
ffout(4)<<"une seule arete cut pbs2\n"; |
// ffout(4)<<"une seule arete cut pbs2\n"; |
1571 |
} |
// } |
1572 |
} |
} |
1573 |
} |
} |
1574 |
} |
} |
1623 |
if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) { |
if(pairTriangleToIntersectionPoints[pairTriangle].size()==2 and isDegenerate==0) { |
1624 |
const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0]; |
const Vertex*& V0=pairTriangleToIntersectionPoints[pairTriangle][0]; |
1625 |
const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1]; |
const Vertex*& V1=pairTriangleToIntersectionPoints[pairTriangle][1]; |
1626 |
if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2)) |
const Triangle T=(*(*jt0)); |
1627 |
and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) { |
real_t epsilon=1e-6; |
1628 |
|
//if((V0==&(*(*jt0))(0) or V0==&(*(*jt0))(1) or V0==&(*(*jt0))(2)) |
1629 |
|
// and (V1==&(*(*jt0))(0) or V1==&(*(*jt0))(1) or V1==&(*(*jt0))(2))) { |
1630 |
|
if(Norm((*V0)-(*V1)) <epsilon and (Norm((*V0)-T(0))<epsilon |
1631 |
|
or Norm((*V0)-T(1))<epsilon |
1632 |
|
or Norm((*V0)-T(2))<epsilon)){ |
1633 |
//ffout(4)<<"inter confondu avec arete\n"; |
//ffout(4)<<"inter confondu avec arete\n"; |
1634 |
isDegenerate=1; |
isDegenerate=1; |
1635 |
} |
} |
1637 |
if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) { |
if(pairTriangleToIntersectionPoints[pairTriangle].size()>=2 and isDegenerate==0) { |
1638 |
for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) { |
for(size_t b=0; b<pairTriangleToIntersectionPoints[pairTriangle].size() ; ++b) { |
1639 |
const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b]; |
const Vertex*& V=pairTriangleToIntersectionPoints[pairTriangle][b]; |
1640 |
if(!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2)) or b==0) { |
const Triangle T=(*(*jt0)); |
1641 |
|
real_t epsilon=1e-6; |
1642 |
|
if(/*!(V==&(*(*jt0))(0) or V==&(*(*jt0))(1) or V==&(*(*jt0))(2))*/ |
1643 |
|
(Norm((*V)-T(0))<epsilon |
1644 |
|
or Norm((*V)-T(1))<epsilon |
1645 |
|
or Norm((*V)-T(2))<epsilon) |
1646 |
|
or b==0) { |
1647 |
if(vertexInTriangles.find(V)==vertexInTriangles.end()) { |
if(vertexInTriangles.find(V)==vertexInTriangles.end()) { |
1648 |
TinyVector<2,const Triangle*> triangles; |
TinyVector<2,const Triangle*> triangles; |
1649 |
triangles[0]=*jt0; |
triangles[0]=*jt0; |
1683 |
numberPointsInterior+=1; |
numberPointsInterior+=1; |
1684 |
size_t r=0; |
size_t r=0; |
1685 |
size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2]; |
size_t sum=cutTriangle[0]+cutTriangle[1]+cutTriangle[2]; |
1686 |
if(sum>3) { |
if(sum>5) { |
1687 |
ffout(4)<<"sum "<<sum<<"\n"<<std::flush; |
ffout(4)<<"sum "<<sum<<"\n"<<std::flush; |
1688 |
} |
} |
1689 |
|
|
1715 |
ffout(4) << K(1) << "\n"; |
ffout(4) << K(1) << "\n"; |
1716 |
ffout(4) << K(2) << "\n"; |
ffout(4) << K(2) << "\n"; |
1717 |
ffout(4) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n"; |
ffout(4) << cutTriangle[0] << " " << cutTriangle[1] << " " << cutTriangle[2] << "\n"; |
1718 |
|
ffout(4) << edgesCut[0] << " " << edgesCut[1] << " " << edgesCut[2] << "\n"; |
1719 |
|
edgesCut[0]=cutTriangle[0]; |
1720 |
|
edgesCut[1]=cutTriangle[1]; |
1721 |
|
edgesCut[2]=cutTriangle[2]; |
1722 |
|
|
1723 |
} |
} |
1724 |
} |
} |
1725 |
if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r]) |
if(pointsInterior.find(pairTriangleToIntersectionPoints[pairTriangle][r]) |
1726 |
==pointsInterior.end()) { |
==pointsInterior.end() and sum<=5) { |
1727 |
pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle][r])] |
pointsInterior[(pairTriangleToIntersectionPoints[pairTriangle][r])] |
1728 |
=(pairTriangleToIntersectionPoints[pairTriangle][r]); |
=(pairTriangleToIntersectionPoints[pairTriangle][r]); |
1729 |
} |
} |
1809 |
const Triangle* T=&(surfmesh.cell(i)); |
const Triangle* T=&(surfmesh.cell(i)); |
1810 |
const Cell* cell=&((*T).mother()); |
const Cell* cell=&((*T).mother()); |
1811 |
if(toTreatHexahedra.find(cell)!=toTreatHexahedra.end() |
if(toTreatHexahedra.find(cell)!=toTreatHexahedra.end() |
1812 |
/*and ((*edgesRefVertex[numobject])[&(*T)(0)]!=0 |
/* and ((*edgesRefVertex[numobject])[&(*T)(0)]!=0 |
1813 |
or (*edgesRefVertex[numobject])[&(*T)(1)]!=0 |
or (*edgesRefVertex[numobject])[&(*T)(1)]!=0 |
1814 |
or (*edgesRefVertex[numobject])[&(*T)(2)]!=0)*/) { |
or (*edgesRefVertex[numobject])[&(*T)(2)]!=0)*/) { |
1815 |
front.push_front(T); |
front.push_front(T); |
1883 |
TinyVector<2,int> edge0=Kneigh.edgecut[0]; |
TinyVector<2,int> edge0=Kneigh.edgecut[0]; |
1884 |
TinyVector<2,int> edge1=Kneigh.edgecut[1]; |
TinyVector<2,int> edge1=Kneigh.edgecut[1]; |
1885 |
TinyVector<2,int> edge2=Kneigh.edgecut[2]; |
TinyVector<2,int> edge2=Kneigh.edgecut[2]; |
|
if(edge0+edge1+edge2==0 and ref0+ref1+ref2!=0 and ref0+ref1+ref2!=6) { |
|
|
ref0=2; |
|
|
ref1=2; |
|
|
ref2=2; |
|
|
test=1; |
|
|
} else { |
|
1886 |
if(ref0+ref1==2 and edge0==0) { |
if(ref0+ref1==2 and edge0==0) { |
1887 |
test=1; |
test=1; |
1888 |
ref0=2; |
ref0=2; |
1904 |
} else if(edge2[0]==1 and ref2+ref1!=2 and ref0+ref1+ref2!=0){ |
} else if(edge2[0]==1 and ref2+ref1!=2 and ref0+ref1+ref2!=0){ |
1905 |
//test=1; |
//test=1; |
1906 |
} |
} |
1907 |
} |
|
1908 |
if(test==1/*ref0+ref1+ref2==6 */or edge0[0]+edge1[0]+edge2[0]==1) { |
if(test==1/*ref0+ref1+ref2==6 *//*or edge0[0]+edge1[0]+edge2[0]==1*/) { |
1909 |
front.push_front(triangle); |
front.push_front(triangle); |
1910 |
} |
} |
1911 |
//ffout(0)<<ref0<<" "<<ref1<<" "<<ref2<<"\n"; |
//ffout(0)<<ref0<<" "<<ref1<<" "<<ref2<<"\n"; |
2357 |
size_t objectNumber=0; |
size_t objectNumber=0; |
2358 |
if(numobject==0) |
if(numobject==0) |
2359 |
objectNumber=1; |
objectNumber=1; |
2360 |
|
// (*edgesRefVertex[numobject]).clear(); |
2361 |
MapCellTriangle hexaToTriangle0=*(O1.hexalist); |
MapCellTriangle hexaToTriangle0=*(O1.hexalist); |
2362 |
|
|
2363 |
|
|
2364 |
std::set<const Cell*> hexaList1; |
std::set<const Cell*> hexaList1; |
2365 |
std::set<const Cell*> hexaListIn; |
std::set<const Cell*> hexaListIn; |
2366 |
|
|
2371 |
std::set_difference (hexaList1.begin(), hexaList1.end(), |
std::set_difference (hexaList1.begin(), hexaList1.end(), |
2372 |
toTreatHexahedra.begin(), toTreatHexahedra.end(), |
toTreatHexahedra.begin(), toTreatHexahedra.end(), |
2373 |
inserter(hexaListIn, hexaListIn.begin())); |
inserter(hexaListIn, hexaListIn.begin())); |
|
|
|
|
for (std::set<const Cell*>::iterator icell = hexaListIn.begin(); icell != hexaListIn.end(); ++icell) { |
|
|
Cell& C = const_cast<Cell&>(*(*icell)); |
|
|
for (size_t i=0; i<C.numberOfVertices(); ++i) { |
|
|
C(i).reference() = ((*O1.shape()).inside(C(i))?1:0) |
|
|
+ ((*O2.shape()).inside(C(i))?1:0); |
|
|
} |
|
|
|
|
|
size_t ref; |
|
|
if (booleanTest::compute(C)) { |
|
|
ref=2; |
|
|
} else { |
|
|
ref=0; |
|
|
} |
|
2374 |
|
|
2375 |
|
ffout(4)<<"taille hexalistIn "<<hexaListIn.size()<<"\n"; |
2376 |
|
for (std::set<const Cell*>::iterator icell = hexaListIn.begin(); icell != hexaListIn.end(); ++icell) { |
2377 |
|
|
2378 |
MapCellTriangle::iterator it0=hexaToTriangle0.find(*icell); |
MapCellTriangle::iterator it0=hexaToTriangle0.find(*icell); |
2379 |
|
|
2380 |
if(it0!=hexaToTriangle0.end()) { |
if(it0!=hexaToTriangle0.end()) { |
2381 |
std::list<Triangle*> listTriangle0=(*it0).second; |
//ffout(4)<<"ici\n"; |
2382 |
|
Cell& C = const_cast<Cell&>(*(*icell)); |
2383 |
|
for (size_t i=0; i<C.numberOfVertices(); ++i) { |
2384 |
|
C(i).reference() = ((*O1.shape()).inside(C(i))?1:0) |
2385 |
|
+ ((*O2.shape()).inside(C(i))?1:0); |
2386 |
|
} |
2387 |
|
|
2388 |
|
size_t ref; |
2389 |
|
if (booleanTest::compute(C)) { |
2390 |
|
ref=2; |
2391 |
|
} else { |
2392 |
|
ref=0; |
2393 |
|
} |
2394 |
|
|
2395 |
|
std::list<Triangle*> listTriangle0=(*it0).second; |
2396 |
|
ffout(4)<<listTriangle0.size()<<"\n"; |
2397 |
for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ; |
for(std::list<Triangle*>::iterator jt0=listTriangle0.begin() ; |
2398 |
jt0!=listTriangle0.end() ; ++jt0) { |
jt0!=listTriangle0.end() ; ++jt0) { |
2399 |
|
|
2400 |
Triangle& T = (*(*jt0)); |
Triangle& T = (*(*jt0)); |
2401 |
for (size_t n=0; n<3; ++n) { |
for (size_t n=0; n<3; ++n) { |
2402 |
|
// if(ref==2) |
2403 |
|
// ffout(4)<<"ref ="<<ref<<"\n"; |
2404 |
(*edgesRefVertex[numobject])[&T(n)]=ref; |
(*edgesRefVertex[numobject])[&T(n)]=ref; |
2405 |
//put ref 2 for points of surfmesh |
//put ref 2 for points of surfmesh |
2406 |
const Vertex* P0=(*listOfVertexMesh.find(&T(n))).second; |
const Vertex* P0=(*listOfVertexMesh.find(&T(n))).second; |
2460 |
|
|
2461 |
ffout(4)<<"cas pbssssss\n"; |
ffout(4)<<"cas pbssssss\n"; |
2462 |
} |
} |
2463 |
|
if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]>=6) { |
2464 |
|
ffout(4)<<"on veut rien faire car triangle plat\n"; |
2465 |
|
ffout(4)<< K.isInTriangle[0]<<" "<< K.isInTriangle[1]<<" "<< K.isInTriangle[2]<<"\n"; |
2466 |
|
K.isInTriangle[0]=1; |
2467 |
|
K.isInTriangle[1]=1; |
2468 |
|
K.isInTriangle[2]=1; |
2469 |
|
|
2470 |
|
} |
2471 |
///////////////////////creation des triangles////////////////////////////// |
///////////////////////creation des triangles////////////////////////////// |
2472 |
size_t numberVertexInDomain=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2]; |
size_t numberVertexInDomain=K.isInTriangle[0]+K.isInTriangle[1]+K.isInTriangle[2]; |
2473 |
switch (numberVertexInDomain) { |
switch (numberVertexInDomain) { |
2486 |
//one edge cut but twice |
//one edge cut but twice |
2487 |
ffout(4)<<"createNotIn\n"; |
ffout(4)<<"createNotIn\n"; |
2488 |
//POUR STEPH : createNotIn peut generer des tr plats |
//POUR STEPH : createNotIn peut generer des tr plats |
2489 |
__createNotIn(K,*i, triangleListIntersectionNew); |
//__createNotIn(K,*i, triangleListIntersectionNew); |
2490 |
} else { |
} else { |
2491 |
if(vertexInTriangles.size()>3 and numberEdgesCut==2) { |
if(vertexInTriangles.size()>3 and numberEdgesCut==2) { |
2492 |
//two edge cut but twice |
//two edge cut but twice |
2493 |
ffout(4)<<"createNotIn2\n"; |
ffout(4)<<"createNotIn2\n"; |
2494 |
__createNotIn2(K,*i, triangleListIntersectionNew); |
//__createNotIn2(K,*i, triangleListIntersectionNew); |
2495 |
} else { |
} else { |
2496 |
if(K.edgecut[0]!=0) { |
if(K.edgecut[0]!=0) { |
2497 |
if(K.pointsIntersection[0][0]==&V0 |
if(K.pointsIntersection[0][0]==&V0 |
2524 |
if(vertexInTriangles.size()>3 and |
if(vertexInTriangles.size()>3 and |
2525 |
K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==1) { |
K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==1) { |
2526 |
ffout(4)<<"case\n"; |
ffout(4)<<"case\n"; |
2527 |
__createNotIn(K,*i,triangleListIntersectionNew); |
//__createNotIn(K,*i,triangleListIntersectionNew); |
2528 |
} |
} |
2529 |
} |
} |
2530 |
} else { |
} else { |
2581 |
and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0] |
and K.pointsIntersection[1][0]!=K.pointsIntersection[2][0] |
2582 |
and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) { |
and K.pointsIntersection[2][0]!=K.pointsIntersection[0][0]) { |
2583 |
ffout(4)<<"---------------- 3 edge cut \n"; |
ffout(4)<<"---------------- 3 edge cut \n"; |
2584 |
__createByEdges(K,*i,triangleListIntersectionNew); |
//__createByEdges(K,*i,triangleListIntersectionNew); |
2585 |
} else { |
} else { |
2586 |
__createListTriangle(K,*i,triangleListIntersectionNew); |
__createListTriangle(K,*i,triangleListIntersectionNew); |
2587 |
} |
} |
2591 |
break; |
break; |
2592 |
} |
} |
2593 |
case 2: { |
case 2: { |
2594 |
|
if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==3) { |
2595 |
|
ffout(4)<<"case 2 pas traite \n"; |
2596 |
|
} else { |
2597 |
__createListTriangle(K,*i,triangleListIntersectionNew); |
__createListTriangle(K,*i,triangleListIntersectionNew); |
2598 |
|
} |
2599 |
break; |
break; |
2600 |
} |
} |
2601 |
case 3: { |
case 3: { |
2602 |
if(K.edgecut[0][0]+K.edgecut[1][0]+K.edgecut[2][0]==0) { |
if(K.edgecut[0]+K.edgecut[1]+K.edgecut[2]==0) { |
2603 |
__addTriangle(*T,*i,triangleListIntersectionNew); |
__addTriangle(*T,*i,triangleListIntersectionNew); |
2604 |
} else { |
} else { |
2605 |
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) { |
3345 |
|
|
3346 |
const Object& object = omega.object(); |
const Object& object = omega.object(); |
3347 |
const Scene& scene = omega.scene(); |
const Scene& scene = omega.scene(); |
3348 |
|
//(*__internals).edgesRefVertex.resize(scene.nbObjects()); |
3349 |
|
(*__internals).edgesRefVertex.resize(2); |
3350 |
|
|
3351 |
(*__internals).edgesRefVertex.resize(scene.nbObjects()); |
for(size_t no=0 ; no<2/*scene.nbObjects()*/ ; ++no) { |
|
|
|
|
for(size_t no=0 ; no<scene.nbObjects() ; ++no) { |
|
3352 |
(*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ; |
(*__internals).edgesRefVertex[no] = new std::map<const Vertex*,size_t> ; |
3353 |
} |
} |
3354 |
|
|