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