23 #ifndef __VCGLIB_TRIALLOCATOR
24 #define __VCGLIB_TRIALLOCATOR
27 #error "This file should not be included alone. It is automatically included by complex.h"
36 template<
class MeshType>
37 size_t Index(
const MeshType &m,
const typename MeshType::VertexType &v) {
return &v-&*m.vert.begin();}
38 template<
class MeshType>
39 size_t Index(
const MeshType &m,
const typename MeshType::FaceType &f) {
return &f-&*m.face.begin();}
40 template<
class MeshType>
41 size_t Index(
const MeshType &m,
const typename MeshType::EdgeType &e) {
return &e-&*m.edge.begin();}
42 template<
class MeshType>
43 size_t Index(
const MeshType &m,
const typename MeshType::HEdgeType &h) {
return &h-&*m.hedge.begin();}
44 template <
class MeshType>
45 size_t Index(
const MeshType &m,
const typename MeshType::TetraType &t) {
return &t - &*m.tetra.begin(); }
48 template<
class MeshType>
49 size_t Index(
const MeshType &m,
const typename MeshType::VertexType *vp) {
return vp-&*m.vert.begin();}
50 template<
class MeshType>
51 size_t Index(
const MeshType &m,
const typename MeshType::FaceType * fp) {
return fp-&*m.face.begin();}
52 template<
class MeshType>
53 size_t Index(
const MeshType &m,
const typename MeshType::EdgeType* e) {
return e-&*m.edge.begin();}
54 template<
class MeshType>
55 size_t Index(
const MeshType &m,
const typename MeshType::HEdgeType* h) {
return h-&*m.hedge.begin();}
56 template <
class MeshType>
57 size_t Index(
const MeshType &m,
const typename MeshType::TetraType *t) {
return t - &*m.tetra.begin(); }
60 template<
class MeshType>
61 bool IsValidPointer( MeshType & m,
const typename MeshType::VertexType *vp) {
return ( m.vert.size() > 0 && (vp >= &*m.vert.begin()) && (vp <= &m.vert.back()) ); }
62 template<
class MeshType>
63 bool IsValidPointer(MeshType & m,
const typename MeshType::EdgeType *ep) {
return ( m.edge.size() > 0 && (ep >= &*m.edge.begin()) && (ep <= &m.edge.back())); }
64 template<
class MeshType>
65 bool IsValidPointer(MeshType & m,
const typename MeshType::FaceType *fp) {
return ( m.face.size() > 0 && (fp >= &*m.face.begin()) && (fp <= &m.face.back())); }
66 template<
class MeshType>
67 bool IsValidPointer(MeshType & m,
const typename MeshType::HEdgeType *hp) {
return ( m.hedge.size() > 0 && (hp >= &*m.hedge.begin()) && (hp <= &m.hedge.back())); }
68 template <
class MeshType>
69 bool IsValidPointer(MeshType &m,
const typename MeshType::TetraType *tp) {
return (m.tetra.size() > 0 && (tp >= &*m.tetra.begin()) && (tp <= &m.tetra.back())); }
71 template <
class MeshType,
class ATTR_CONT>
72 void ReorderAttribute(ATTR_CONT &c, std::vector<size_t> & newVertIndex, MeshType & ){
73 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
74 for(ai = c.begin(); ai != c.end(); ++ai)
75 ((
typename MeshType::PointerToAttribute)(*ai)).Reorder(newVertIndex);
78 template <
class MeshType,
class ATTR_CONT>
79 void ResizeAttribute(ATTR_CONT &c,
size_t sz, MeshType &){
80 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
81 for(ai =c.begin(); ai != c.end(); ++ai)
82 ((
typename MeshType::PointerToAttribute)(*ai)).Resize(sz);
92 template <
class MeshType>
97 typedef typename MeshType::VertexType VertexType;
98 typedef typename MeshType::VertexPointer VertexPointer;
99 typedef typename MeshType::VertexIterator VertexIterator;
100 typedef typename MeshType::VertContainer VertContainer;
102 typedef typename MeshType::EdgeType EdgeType;
103 typedef typename MeshType::EdgePointer EdgePointer;
104 typedef typename MeshType::EdgeIterator EdgeIterator;
105 typedef typename MeshType::EdgeContainer EdgeContainer;
107 typedef typename MeshType::FaceType FaceType;
108 typedef typename MeshType::FacePointer FacePointer;
109 typedef typename MeshType::FaceIterator FaceIterator;
110 typedef typename MeshType::FaceContainer FaceContainer;
112 typedef typename MeshType::HEdgeType HEdgeType;
113 typedef typename MeshType::HEdgePointer HEdgePointer;
114 typedef typename MeshType::HEdgeIterator HEdgeIterator;
115 typedef typename MeshType::HEdgeContainer HEdgeContainer;
117 typedef typename MeshType::TetraType TetraType;
118 typedef typename MeshType::TetraPointer TetraPointer;
119 typedef typename MeshType::TetraIterator TetraIterator;
120 typedef typename MeshType::TetraContainer TetraContainer;
122 typedef typename MeshType::CoordType CoordType;
124 typedef typename MeshType::PointerToAttribute PointerToAttribute;
125 typedef typename std::set<PointerToAttribute>::iterator AttrIterator;
126 typedef typename std::set<PointerToAttribute>::const_iterator AttrConstIterator;
127 typedef typename std::set<PointerToAttribute >::iterator PAIte;
140 template<
class SimplexPo
interType>
144 PointerUpdater(
void) : newBase(0), oldBase(0), newEnd(0), oldEnd(0), preventUpdateFlag(
false) { ; }
145 void Clear(){newBase=oldBase=newEnd=oldEnd=0; remap.clear();}
153 if(vp<oldBase || vp>oldEnd)
return;
156 vp=newBase+(vp-oldBase);
158 vp = newBase + remap[vp-newBase];
163 bool NeedUpdate() {
if((oldBase && newBase!=oldBase && !preventUpdateFlag) || !remap.empty())
return true;
else return false;}
165 SimplexPointerType newBase;
166 SimplexPointerType oldBase;
167 SimplexPointerType newEnd;
168 SimplexPointerType oldEnd;
169 std::vector<size_t> remap;
171 bool preventUpdateFlag;
196 pu.oldBase=&*m.vert.begin();
197 pu.oldEnd=&m.vert.back()+1;
200 m.vert.resize(m.vert.size()+n);
203 typename std::set<PointerToAttribute>::iterator ai;
204 for(ai = m.vert_attr.begin(); ai != m.vert_attr.end(); ++ai)
205 ((PointerToAttribute)(*ai)).Resize(m.vert.size());
207 pu.newBase = &*m.vert.begin();
208 pu.newEnd = &m.vert.back()+1;
211 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi)
213 for(
int i=0; i < (*fi).VN(); ++i)
214 if ((*fi).cV(i)!=0) pu.Update((*fi).V(i));
216 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
220 pu.Update((*ei).V(0));
221 pu.Update((*ei).V(1));
226 for (hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
229 if(HasHVAdjacency (m))
231 pu.Update((*hi).HVp());
235 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
237 for (
int i = 0; i < 4; ++i)
238 if ((*ti).cV(i) != 0)
239 pu.Update((*ti).V(i));
243 size_t siz=(size_t)(m.vert.size()-n);
245 last = m.vert.begin();
253 static VertexIterator AddVertices(MeshType &m,
size_t n)
256 return AddVertices(m, n,pu);
261 static VertexIterator AddVertices(MeshType &m,
size_t n, std::vector<VertexPointer *> &local_vec)
264 VertexIterator v_ret = AddVertices(m, n,pu);
266 typename std::vector<VertexPointer *>::iterator vi;
267 for(vi=local_vec.begin();vi!=local_vec.end();++vi)
274 static VertexIterator AddVertex(MeshType &m,
const CoordType &p)
276 VertexIterator v_ret = AddVertices(m, 1);
283 static VertexIterator AddVertex(MeshType &m,
const CoordType &p,
const CoordType &n)
285 VertexIterator v_ret = AddVertices(m, 1);
293 static VertexIterator AddVertex(MeshType &m,
const CoordType &p,
const Color4b &c)
295 VertexIterator v_ret = AddVertices(m, 1);
314 if(n == 0)
return m.edge.end();
316 if(m.edge.empty()) pu.oldBase=0;
318 pu.oldBase=&*m.edge.begin();
319 pu.oldEnd=&m.edge.back()+1;
322 m.edge.resize(m.edge.size()+n);
324 size_t siz=(size_t)(m.edge.size()-n);
325 EdgeIterator firstNewEdge = m.edge.begin();
326 advance(firstNewEdge,siz);
328 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
329 for(ai = m.edge_attr.begin(); ai != m.edge_attr.end(); ++ai)
330 ((
typename MeshType::PointerToAttribute)(*ai)).Resize(m.edge.size());
332 pu.newBase = &*m.edge.begin();
333 pu.newEnd = &m.edge.back()+1;
336 if(HasFEAdjacency(m))
337 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi){
339 for(
int i=0; i < (*fi).VN(); ++i)
340 if ((*fi).cFEp(i)!=0) pu.Update((*fi).FEp(i));
343 if(HasVEAdjacency(m)){
344 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
346 if ((*vi).cVEp()!=0) pu.Update((*vi).VEp());
347 for(EdgeIterator ei=m.edge.begin();ei!=firstNewEdge;++ei)
350 if ((*ei).cVEp(0)!=0) pu.Update((*ei).VEp(0));
351 if ((*ei).cVEp(1)!=0) pu.Update((*ei).VEp(1));
355 if(HasHEAdjacency(m))
356 for (HEdgeIterator hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
358 if ((*hi).cHEp()!=0) pu.Update((*hi).HEp());
366 static EdgeIterator AddEdge(MeshType &m, VertexPointer v0, VertexPointer v1)
368 EdgeIterator ei= AddEdges(m, 1);
376 static EdgeIterator AddEdge(MeshType &m,
size_t v0,
size_t v1)
379 assert(v0>=0 && v0<m.vert.size());
380 assert(v1>=0 && v1<m.vert.size());
381 return AddEdge(m,&(m.vert[v0]),&(m.vert[v1]));
387 static EdgeIterator AddEdge(MeshType &m, CoordType p0, CoordType p1)
389 VertexIterator vi = AddVertices(m,2);
390 EdgeIterator ei = AddEdges(m,1);
401 static EdgeIterator AddEdges(MeshType &m,
size_t n)
404 return AddEdges(m, n,pu);
410 static EdgeIterator AddEdges(MeshType &m,
size_t n, std::vector<EdgePointer*> &local_vec)
413 EdgeIterator v_ret = AddEdges(m, n,pu);
415 typename std::vector<EdgePointer *>::iterator ei;
416 for(ei=local_vec.begin();ei!=local_vec.end();++ei)
435 if(n == 0)
return m.hedge.end();
437 if(m.hedge.empty()) pu.oldBase=0;
439 pu.oldBase=&*m.hedge.begin();
440 pu.oldEnd=&m.hedge.back()+1;
443 m.hedge.resize(m.hedge.size()+n);
446 pu.newBase = &*m.hedge.begin();
447 pu.newEnd = &m.hedge.back()+1;
451 if(HasFHAdjacency(m)) {
452 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi)
454 if(!(*fi).IsD() && (*fi).FHp())
455 pu.Update((*fi).FHp());
458 if(HasVHAdjacency(m)) {
459 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
460 if(!(*vi).IsD() && (*vi).cVHp()!=0)
461 pu.Update((*vi).VHp());
463 if(HasEHAdjacency(m)) {
464 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
465 if(!(*ei).IsD() && (*ei).cEHp()!=0)
466 pu.Update((*ei).EHp());
470 HEdgeIterator hi = m.hedge.begin();
471 while(ii < m.hn -
int(n))
475 if(HasHNextAdjacency(m)) pu.Update((*hi).HNp());
476 if(HasHPrevAdjacency(m)) pu.Update((*hi).HPp());
477 if(HasHOppAdjacency(m)) pu.Update((*hi).HOp());
483 size_t siz = (size_t)(m.hedge.size()-n);
485 last = m.hedge.begin();
494 static HEdgeIterator AddHEdges(MeshType &m,
size_t n)
497 return AddHEdges(m, n,pu);
503 static HEdgeIterator AddHEdges(MeshType &m,
size_t n, std::vector<HEdgePointer*> &local_vec)
506 HEdgeIterator v_ret = AddHEdges(m, n,pu);
508 typename std::vector<HEdgePointer *>::iterator ei;
509 for(ei=local_vec.begin();ei!=local_vec.end();++ei)
518 static FaceIterator AddFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2)
520 assert(m.vert.size()>0);
521 assert((v0!=v1) && (v1!=v2) && (v0!=v2));
522 assert(v0>=&m.vert.front() && v0<=&m.vert.back());
523 assert(v1>=&m.vert.front() && v1<=&m.vert.back());
524 assert(v2>=&m.vert.front() && v2<=&m.vert.back());
526 FaceIterator fi = AddFaces(m,1,pu);
536 static FaceIterator AddFace(MeshType &m,
size_t v0,
size_t v1,
size_t v2)
538 assert((v0!=v1) && (v1!=v2) && (v0!=v2));
539 assert(v0>=0 && v0<m.vert.size());
540 assert(v1>=0 && v1<m.vert.size());
541 assert(v2>=0 && v2<m.vert.size());
542 return AddFace(m,&(m.vert[v0]),&(m.vert[v1]),&(m.vert[v2]));
546 static FaceIterator AddFace(MeshType &m, CoordType p0, CoordType p1, CoordType p2)
548 VertexIterator vi = AddVertices(m,3);
549 FaceIterator fi = AddFaces(m,1);
564 static FaceIterator AddQuadFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
566 assert(m.vert.size()>0);
567 assert(v0>=&m.vert.front() && v0<=&m.vert.back());
568 assert(v1>=&m.vert.front() && v1<=&m.vert.back());
569 assert(v2>=&m.vert.front() && v2<=&m.vert.back());
570 assert(v3>=&m.vert.front() && v3<=&m.vert.back());
572 if(FaceType::HasPolyInfo())
574 FaceIterator fi = AddFaces(m,1,pu);
576 fi->V(0)=v0; fi->V(1)=v1;
577 fi->V(2)=v2; fi->V(3)=v3;
582 FaceIterator fi = AddFaces(m,2,pu);
583 fi->Alloc(3); fi->V(0)=v0; fi->V(1)=v1; fi->V(2)=v2;
586 fi->Alloc(3); fi->V(0)=v0; fi->V(1)=v2; fi->V(2)=v3;
594 static FaceIterator AddFaces(MeshType &m,
size_t n)
597 return AddFaces(m,n,pu);
603 static FaceIterator AddFaces(MeshType &m,
size_t n,std::vector<FacePointer *> &local_vec)
606 FaceIterator f_ret= AddFaces(m,n,pu);
608 typename std::vector<FacePointer *>::iterator fi;
609 for(fi=local_vec.begin();fi!=local_vec.end();++fi)
629 if(n == 0)
return m.face.end();
632 pu.oldBase=&*m.face.begin();
633 pu.oldEnd=&m.face.back()+1;
636 m.face.resize(m.face.size()+n);
639 size_t siz=(size_t)(m.face.size()-n);
640 FaceIterator firstNewFace = m.face.begin();
641 advance(firstNewFace,siz);
643 typename std::set<PointerToAttribute>::iterator ai;
644 for(ai = m.face_attr.begin(); ai != m.face_attr.end(); ++ai)
645 ((PointerToAttribute)(*ai)).Resize(m.face.size());
647 pu.newBase = &*m.face.begin();
648 pu.newEnd = &m.face.back()+1;
652 if(HasFFAdjacency(m))
654 for(FaceIterator fi=m.face.begin();fi!=firstNewFace;++fi)
656 for(
int i = 0; i < (*fi).VN(); ++i)
657 if ((*fi).cFFp(i)!=0) pu.
Update((*fi).FFp(i));
660 if(HasPerVertexVFAdjacency(m) && HasPerFaceVFAdjacency(m))
662 for(FaceIterator fi=m.face.begin();fi!=firstNewFace;++fi)
664 for(
int i = 0; i < (*fi).VN(); ++i)
665 if ((*fi).cVFp(i)!=0) pu.
Update((*fi).VFp(i));
667 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
668 if(!(*vi).IsD() && (*vi).cVFp()!=0)
672 if(HasEFAdjacency(m))
674 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
675 if(!(*ei).IsD() && (*ei).cEFp()!=0)
679 if(HasHFAdjacency(m))
681 for (HEdgeIterator hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
682 if(!(*hi).IsD() && (*hi).cHFp()!=0)
708 return m.tetra.end();
716 pu.oldBase = &*m.tetra.begin();
717 pu.oldEnd = &m.tetra.back() + 1;
721 m.tetra.resize(m.tetra.size() + n);
725 size_t oldSize = (size_t)(m.tetra.size() - n);
727 TetraIterator firstNewTetra = m.tetra.begin();
728 advance(firstNewTetra, oldSize);
731 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
732 for (ai = m.tetra_attr.begin(); ai != m.tetra_attr.end(); ++ai)
733 ((
typename MeshType::PointerToAttribute)(*ai)).Resize(m.tetra.size());
736 pu.newBase = &*m.tetra.begin();
737 pu.newEnd = &m.tetra.back() + 1;
740 if (HasVTAdjacency(m))
742 for (VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
744 pu.Update(vi->VTp());
746 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
749 pu.Update(ti->VTp(0));
750 pu.Update(ti->VTp(1));
751 pu.Update(ti->VTp(2));
752 pu.Update(ti->VTp(3));
757 if (HasTTAdjacency(m))
758 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
761 pu.Update(ti->TTp(0));
762 pu.Update(ti->TTp(1));
763 pu.Update(ti->TTp(2));
764 pu.Update(ti->TTp(3));
768 return firstNewTetra;
774 static TetraIterator AddTetra(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
776 assert(m.vert.size() > 0);
777 assert((v0 != v1) && (v0 != v2) && (v0 != v3) && (v1 != v2) && (v1 != v3) && (v2 != v3));
778 assert(v0 >= &m.vert.front() && v0 <= &m.vert.back());
779 assert(v1 >= &m.vert.front() && v1 <= &m.vert.back());
780 assert(v2 >= &m.vert.front() && v2 <= &m.vert.back());
781 assert(v3 >= &m.vert.front() && v3 <= &m.vert.back());
789 TetraIterator ti = AddTetras(m, 1, pu);
799 static TetraIterator AddTetra(MeshType &m,
const size_t v0,
const size_t v1,
const size_t v2,
const size_t v3)
801 assert(m.vert.size() > 0);
802 assert((v0 != v1) && (v0 != v2) && (v0 != v3) && (v1 != v2) && (v1 != v3) && (v2 != v3));
803 assert(v0 >= 0 && v0 < m.vert.size());
804 assert(v1 >= 0 && v1 < m.vert.size());
805 assert(v2 >= 0 && v2 < m.vert.size());
806 assert(v3 >= 0 && v3 < m.vert.size());
808 return AddTetra(m, &(m.vert[v0]), &(m.vert[v1]), &(m.vert[v2]), &(m.vert[v3]));
812 static TetraIterator AddTetra(MeshType &m,
const CoordType & p0,
const CoordType & p1,
const CoordType & p2,
const CoordType & p3)
814 VertexIterator vi = AddVertices(m, 4);
816 VertexPointer v0 = &*vi++;
817 VertexPointer v1 = &*vi++;
818 VertexPointer v2 = &*vi++;
819 VertexPointer v3 = &*vi++;
826 return AddTetra(m, v0, v1, v2, v3);
859 static TetraIterator AddTetras(MeshType &m,
size_t n)
862 return AddTetras(m, n, pu);
868 static TetraIterator AddTetras(MeshType &m,
size_t n, std::vector<TetraPointer *> &local_vec)
871 TetraIterator t_ret = AddTetras(m, n, pu);
873 typename std::vector<TetraPointer *>::iterator ti;
874 for (ti = local_vec.begin(); ti != local_vec.end(); ++ti)
884 static void DeleteFace(MeshType &m, FaceType &f)
886 assert(&f >= &m.face.front() && &f <= &m.face.back());
896 static void DeleteVertex(MeshType &m, VertexType &v)
898 assert(&v >= &m.vert.front() && &v <= &m.vert.back());
907 static void DeleteEdge(MeshType &m, EdgeType &e)
909 assert(&e >= &m.edge.front() && &e <= &m.edge.back());
918 static void DeleteHEdge(MeshType &m, HEdgeType &h)
920 assert(&h >= &m.hedge.front() && &h <= &m.hedge.back());
929 static void DeleteTetra(MeshType &m, TetraType &t)
931 assert(&t >= &m.tetra.front() && &t <= &m.tetra.back());
946 static void PermutateVertexVector(MeshType &m, PointerUpdater<VertexPointer> &pu)
948 if(m.vert.empty())
return;
949 for(
size_t i=0;i<m.vert.size();++i)
951 if(pu.remap[i]<
size_t(m.vn))
953 assert(!m.vert[i].IsD());
954 m.vert[ pu.remap [i] ].ImportData(m.vert[i]);
955 if(HasVFAdjacency(m))
957 if (m.vert[i].IsVFInitialized())
959 m.vert[ pu.remap[i] ].VFp() = m.vert[i].cVFp();
960 m.vert[ pu.remap[i] ].VFi() = m.vert[i].cVFi();
962 else m.vert [ pu.remap[i] ].VFClear();
964 if(HasVEAdjacency(m))
966 if (m.vert[i].IsVEInitialized())
968 m.vert[ pu.remap[i] ].VEp() = m.vert[i].cVEp();
969 m.vert[ pu.remap[i] ].VEi() = m.vert[i].cVEi();
971 else m.vert [ pu.remap[i] ].VEClear();
973 if (HasVTAdjacency(m))
975 if (m.vert[i].IsVTInitialized())
977 m.vert[ pu.remap[i] ].VTp() = m.vert[i].cVTp();
978 m.vert[ pu.remap[i] ].VTi() = m.vert[i].cVTi();
980 else m.vert[ pu.remap[i] ].VTClear();
986 ReorderAttribute(m.vert_attr,pu.remap,m);
989 pu.oldBase = &m.vert[0];
990 pu.oldEnd = &m.vert.back()+1;
996 pu.newBase = (m.vert.empty())?0:&m.vert[0];
997 pu.newEnd = (m.vert.empty())?0:&m.vert.back()+1;
1000 ResizeAttribute(m.vert_attr,m.vn,m);
1003 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
1005 for(
int i=0;i<fi->VN();++i)
1007 size_t oldIndex = (*fi).V(i) - pu.oldBase;
1008 assert(pu.oldBase <= (*fi).V(i) && oldIndex < pu.remap.size());
1009 (*fi).V(i) = pu.newBase+pu.remap[oldIndex];
1012 for(TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
1014 for(
int i = 0; i < 4; ++i)
1016 size_t oldIndex = (*ti).V(i) - pu.oldBase;
1017 assert(pu.oldBase <= (*ti).V(i) && oldIndex < pu.remap.size());
1018 (*ti).V(i) = pu.newBase+pu.remap[oldIndex];
1022 for(EdgeIterator ei=m.edge.begin();ei!=m.edge.end();++ei)
1025 pu.Update((*ei).V(0));
1026 pu.Update((*ei).V(1));
1030 static void CompactEveryVector(MeshType &m)
1032 CompactVertexVector(m);
1033 CompactEdgeVector(m);
1034 CompactFaceVector(m);
1035 CompactTetraVector(m);
1048 if(m.vn==(
int)m.vert.size())
return;
1051 pu.remap.resize( m.vert.size(),std::numeric_limits<size_t>::max() );
1056 for(i=0;i<m.vert.size();++i)
1058 if(!m.vert[i].IsD())
1064 assert((
int)pos==m.vn);
1066 PermutateVertexVector(m, pu);
1072 CompactVertexVector(m,pu);
1086 if(m.en==(
int)m.edge.size())
return;
1089 pu.remap.resize( m.edge.size(),std::numeric_limits<size_t>::max() );
1094 for(i=0;i<m.edge.size();++i)
1096 if(!m.edge[i].IsD())
1102 assert((
int)pos==m.en);
1105 for(
size_t i=0;i<m.edge.size();++i)
1107 if(pu.remap[i]<
size_t(m.en))
1109 assert(!m.edge[i].IsD());
1110 m.edge[ pu.remap [i] ].ImportData(m.edge[i]);
1112 m.edge[ pu.remap[i] ].V(0) = m.edge[i].cV(0);
1113 m.edge[ pu.remap[i] ].V(1) = m.edge[i].cV(1);
1115 if(HasVEAdjacency(m))
1118 m.edge[ pu.remap[i] ].VEp(0) = m.edge[i].cVEp(0);
1119 m.edge[ pu.remap[i] ].VEi(0) = m.edge[i].cVEi(0);
1120 m.edge[ pu.remap[i] ].VEp(1) = m.edge[i].cVEp(1);
1121 m.edge[ pu.remap[i] ].VEi(1) = m.edge[i].cVEi(1);
1123 if(HasEEAdjacency(m))
1126 m.edge[ pu.remap[i] ].EEp(0) = m.edge[i].cEEp(0);
1127 m.edge[ pu.remap[i] ].EEi(0) = m.edge[i].cEEi(0);
1128 m.edge[ pu.remap[i] ].EEp(1) = m.edge[i].cEEp(1);
1129 m.edge[ pu.remap[i] ].EEi(1) = m.edge[i].cEEi(1);
1131 if(HasEFAdjacency(m))
1134 m.edge[ pu.remap[i] ].EFp() = m.edge[i].cEFp();
1135 m.edge[ pu.remap[i] ].EFi() = m.edge[i].cEFi();
1136 m.edge[ pu.remap[i] ].EFp() = m.edge[i].cEFp();
1137 m.edge[ pu.remap[i] ].EFi() = m.edge[i].cEFi();
1144 ReorderAttribute(m.edge_attr, pu.remap,m);
1147 pu.oldBase = &m.edge[0];
1148 pu.oldEnd = &m.edge.back()+1;
1151 m.edge.resize(m.en);
1154 pu.newBase = (m.edge.empty())?0:&m.edge[0];
1155 pu.newEnd = (m.edge.empty())?0:&m.edge.back()+1;
1158 ResizeAttribute(m.edge_attr,m.en,m);
1161 if(HasVEAdjacency(m))
1162 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
1163 if(!(*vi).IsD()) pu.
Update((*vi).VEp());
1166 for(EdgeIterator ei=m.edge.begin();ei!=m.edge.end();++ei)
1167 for(
unsigned int i=0;i<2;++i)
1169 if(HasVEAdjacency(m))
1171 if(HasEEAdjacency(m))
1181 CompactEdgeVector(m,pu);
1195 if(m.fn==(
int)m.face.size())
return;
1198 pu.remap.resize( m.face.size(),std::numeric_limits<size_t>::max() );
1201 for(
size_t i=0;i<m.face.size();++i)
1203 if(!m.face[i].IsD())
1207 m.face[pos].ImportData(m.face[i]);
1208 if(FaceType::HasPolyInfo())
1210 m.face[pos].Dealloc();
1211 m.face[pos].Alloc(m.face[i].VN());
1213 for(
int j=0;j<m.face[i].VN();++j)
1214 m.face[pos].V(j) = m.face[i].V(j);
1216 if(HasVFAdjacency(m))
1217 for(
int j=0;j<m.face[i].VN();++j)
1219 if (m.face[i].IsVFInitialized(j)) {
1220 m.face[pos].VFp(j) = m.face[i].cVFp(j);
1221 m.face[pos].VFi(j) = m.face[i].cVFi(j);
1223 else m.face[pos].VFClear(j);
1225 if(HasFFAdjacency(m))
1226 for(
int j=0;j<m.face[i].VN();++j)
1228 m.face[pos].FFp(j) = m.face[i].cFFp(j);
1229 m.face[pos].FFi(j) = m.face[i].cFFi(j);
1236 assert((
int)pos==m.fn);
1239 ReorderAttribute(m.face_attr,pu.remap,m);
1241 FacePointer fbase=&m.face[0];
1244 if(HasVFAdjacency(m))
1246 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
1249 if ((*vi).IsVFInitialized() && (*vi).VFp()!=0 )
1251 size_t oldIndex = (*vi).cVFp() - fbase;
1252 assert(fbase <= (*vi).cVFp() && oldIndex < pu.remap.size());
1253 (*vi).VFp() = fbase+pu.remap[oldIndex];
1259 pu.oldBase = &m.face[0];
1260 pu.oldEnd = &m.face.back()+1;
1261 for(
size_t i=m.fn;i<m.face.size();++i)
1262 m.face[i].Dealloc();
1263 m.face.resize(m.fn);
1264 pu.newBase = (m.face.empty())?0:&m.face[0];
1265 pu.newEnd = (m.face.empty())?0:&m.face.back()+1;
1269 ResizeAttribute(m.face_attr,m.fn,m);
1272 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
1275 if(HasVFAdjacency(m))
1276 for(
int i=0;i<(*fi).VN();++i)
1277 if ((*fi).IsVFInitialized(i) && (*fi).VFp(i)!=0 )
1279 size_t oldIndex = (*fi).VFp(i) - fbase;
1280 assert(fbase <= (*fi).VFp(i) && oldIndex < pu.remap.size());
1281 (*fi).VFp(i) = fbase+pu.remap[oldIndex];
1283 if(HasFFAdjacency(m))
1284 for(
int i=0;i<(*fi).VN();++i)
1285 if ((*fi).cFFp(i)!=0)
1287 size_t oldIndex = (*fi).FFp(i) - fbase;
1288 assert(fbase <= (*fi).FFp(i) && oldIndex < pu.remap.size());
1289 (*fi).FFp(i) = fbase+pu.remap[oldIndex];
1300 CompactFaceVector(m,pu);
1314 if (
size_t(m.tn) == m.tetra.size())
1318 pu.remap.resize(m.tetra.size(), std::numeric_limits<size_t>::max());
1323 for (
size_t i = 0; i < m.tetra.size(); ++i)
1325 if (!m.tetra[i].IsD())
1330 m.tetra[pos].ImportData(m.tetra[i]);
1332 for (
int j = 0; j < 4; ++j)
1333 m.tetra[pos].V(j) = m.tetra[i].V(j);
1335 if (HasVTAdjacency(m))
1336 for (
int j = 0; j < 4; ++j)
1338 if (m.tetra[i].IsVTInitialized(j))
1340 m.tetra[pos].VTp(j) = m.tetra[i].VTp(j);
1341 m.tetra[pos].VTi(j) = m.tetra[i].VTi(j);
1344 m.tetra[pos].VTClear(j);
1347 if (HasTTAdjacency(m))
1348 for (
int j = 0; j < 4; ++j)
1350 m.tetra[pos].TTp(j) = m.tetra[i].cTTp(j);
1351 m.tetra[pos].TTi(j) = m.tetra[i].cTTi(j);
1360 assert(
size_t(m.tn) == pos);
1362 ReorderAttribute(m.tetra_attr, pu.remap, m);
1364 ResizeAttribute(m.tetra_attr, m.tn, m);
1367 pu.oldBase = &m.tetra[0];
1368 pu.oldEnd = &m.tetra.back() + 1;
1370 m.tetra.resize(m.tn);
1371 pu.newBase = (m.tetra.empty()) ? 0 : &m.tetra[0];
1372 pu.newEnd = (m.tetra.empty()) ? 0 : &m.tetra.back() + 1;
1374 TetraPointer tbase = &m.tetra[0];
1377 if (HasVTAdjacency(m))
1379 for (VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
1382 if ((*vi).IsVTInitialized() && (*vi).VTp() != 0)
1384 size_t oldIndex = (*vi).cVTp() - tbase;
1385 assert(tbase <= (*vi).cVTp() && oldIndex < pu.remap.size());
1386 (*vi).VTp() = tbase + pu.remap[oldIndex];
1392 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
1396 if (HasVTAdjacency(m))
1397 for (
int i = 0; i < 4; ++i)
1398 if ((*ti).IsVTInitialized(i) && (*ti).VTp(i) != 0)
1400 size_t oldIndex = (*ti).VTp(i) - tbase;
1401 assert(tbase <= (*ti).VTp(i) && oldIndex < pu.remap.size());
1402 (*ti).VTp(i) = tbase + pu.remap[oldIndex];
1405 if (HasTTAdjacency(m))
1406 for (
int i = 0; i < 4; ++i)
1407 if ((*ti).cTTp(i) != 0)
1409 size_t oldIndex = (*ti).TTp(i) - tbase;
1410 assert(tbase <= (*ti).TTp(i) && oldIndex < pu.remap.size());
1411 (*ti).TTp(i) = tbase + pu.remap[oldIndex];
1417 static void CompactTetraVector(MeshType &m)
1420 CompactTetraVector(m, pu);
1428 template <
class ATTR_TYPE>
1430 bool IsValidHandle( MeshType & m,
const typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> & a){
1431 if(a._handle == NULL)
return false;
1432 for(AttrIterator i = m.vert_attr.begin(); i!=m.vert_attr.end();++i)
1433 if ( (*i).n_attr == a.n_attr )
return true;
1441 template <
class ATTR_TYPE>
1443 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1446 PointerToAttribute h;
1449 i = m.vert_attr.find(h);
1450 assert(i ==m.vert_attr.end() );
1453 h._sizeof =
sizeof(ATTR_TYPE);
1455 h._handle =
new SimpleTempData<VertContainer,ATTR_TYPE>(m.vert);
1456 h._type =
typeid(ATTR_TYPE);
1459 std::pair < AttrIterator , bool> res = m.vert_attr.insert(h);
1460 return typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr );
1463 template <
class ATTR_TYPE>
1464 static typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1465 AddPerVertexAttribute( MeshType & m){
1466 return AddPerVertexAttribute<ATTR_TYPE>(m,std::string(
""));
1473 template <
class ATTR_TYPE>
1475 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1477 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> h;
1479 h = FindPerVertexAttribute<ATTR_TYPE>(m,name);
1480 if(IsValidHandle(m,h))
1483 return AddPerVertexAttribute<ATTR_TYPE>(m,name);
1489 template <
class ATTR_TYPE>
1490 static typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1491 FindPerVertexAttribute( MeshType & m,
const std::string & name)
1493 assert(!name.empty());
1494 PointerToAttribute h1; h1._name = name;
1495 typename std::set<PointerToAttribute > :: iterator i;
1497 i =m.vert_attr.find(h1);
1498 if(i!=m.vert_attr.end())
1499 if((*i)._sizeof ==
sizeof(ATTR_TYPE) ){
1500 if( (*i)._padding != 0 ){
1501 PointerToAttribute attr = (*i);
1502 m.vert_attr.erase(i);
1503 FixPaddedPerVertexAttribute<ATTR_TYPE>(m,attr);
1504 std::pair<AttrIterator,bool> new_i = m.vert_attr.insert(attr);
1505 assert(new_i.second);
1508 return typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1510 return typename MeshType:: template PerVertexAttributeHandle<ATTR_TYPE>(NULL,0);
1516 template <
class ATTR_TYPE>
1519 typename std::set<PointerToAttribute > ::const_iterator i;
1520 for(i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i )
1521 if(!(*i)._name.empty())
1523 typename MeshType:: template PerVertexAttributeHandle<ATTR_TYPE> hh;
1525 if(IsValidHandle<ATTR_TYPE>(m,hh))
1526 all.push_back((*i)._name);
1530 template <
class ATTR_TYPE>
1533 ClearPerVertexAttribute( MeshType & m,
typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> & h,
const ATTR_TYPE & initVal = ATTR_TYPE()){
1534 typename std::set<PointerToAttribute > ::iterator i;
1535 for( i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i)
1536 if( (*i)._handle == h._handle ){
1537 for(
typename MeshType::VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
1545 template <
class ATTR_TYPE>
1549 typename std::set<PointerToAttribute > ::iterator i;
1550 for( i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i)
1551 if( (*i)._handle == h._handle ){
1552 delete ((SimpleTempData<VertContainer,ATTR_TYPE>*)(*i)._handle);
1553 m.vert_attr.erase(i);
1561 bool DeletePerVertexAttribute( MeshType & m, std::string name){
1563 PointerToAttribute h1; h1._name = name;
1564 i = m.vert_attr.find(h1);
1565 if(i==m.vert_attr.end())
return false;
1566 delete ((SimpleTempDataBase*)(*i)._handle);
1567 m.vert_attr.erase(i);
1574 template <
class ATTR_TYPE>
1576 bool IsValidHandle( MeshType & m,
const typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE> & a){
1577 if(a._handle == NULL)
return false;
1578 for(AttrIterator i = m.edge_attr.begin(); i!=m.edge_attr.end();++i)
1579 if ( (*i).n_attr == a.n_attr )
return true;
1583 template <
class ATTR_TYPE>
1585 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1586 AddPerEdgeAttribute( MeshType & m, std::string name){
1588 PointerToAttribute h;
1591 i = m.edge_attr.find(h);
1592 assert(i ==m.edge_attr.end() );
1594 h._sizeof =
sizeof(ATTR_TYPE);
1597 h._handle =
new SimpleTempData<EdgeContainer,ATTR_TYPE>(m.edge);
1598 h._type =
typeid(ATTR_TYPE);
1601 std::pair < AttrIterator , bool> res = m.edge_attr.insert(h);
1602 return typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
1605 template <
class ATTR_TYPE>
1607 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1608 AddPerEdgeAttribute( MeshType & m){
1609 return AddPerEdgeAttribute<ATTR_TYPE>(m,std::string(
""));
1616 template <
class ATTR_TYPE>
1618 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1620 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE> h;
1622 h = FindPerEdgeAttribute<ATTR_TYPE>(m,name);
1623 if(IsValidHandle(m,h))
1626 return AddPerEdgeAttribute<ATTR_TYPE>(m,name);
1630 template <
class ATTR_TYPE>
1632 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1633 FindPerEdgeAttribute( MeshType & m,
const std::string & name){
1634 assert(!name.empty());
1635 PointerToAttribute h1; h1._name = name;
1636 typename std::set<PointerToAttribute > ::const_iterator i;
1638 i =m.edge_attr.find(h1);
1639 if(i!=m.edge_attr.end())
1640 if((*i)._sizeof ==
sizeof(ATTR_TYPE) ){
1641 if( (*i)._padding != 0 ){
1642 PointerToAttribute attr = (*i);
1643 m.edge_attr.erase(i);
1644 FixPaddedPerEdgeAttribute<ATTR_TYPE>(m,attr);
1645 std::pair<AttrIterator,bool> new_i = m.edge_attr.insert(attr);
1646 assert(new_i.second);
1649 return typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1652 return typename MeshType:: template PerEdgeAttributeHandle<ATTR_TYPE>(NULL,0);
1655 template <
class ATTR_TYPE>
1656 static void GetAllPerEdgeAttribute(
const MeshType & m, std::vector<std::string> &all){
1658 typename std::set<PointerToAttribute > :: const_iterator i;
1659 for(i = m.edge_attr.begin(); i != m.edge_attr.end(); ++i )
1660 if(!(*i)._name.empty())
1662 typename MeshType:: template PerEdgeAttributeHandle<ATTR_TYPE> hh;
1663 hh = Allocator<MeshType>:: template FindPerEdgeAttribute <ATTR_TYPE>(m,(*i)._name);
1664 if(IsValidHandle<ATTR_TYPE>(m,hh))
1665 all.push_back((*i)._name);
1671 template <
class ATTR_TYPE>
1675 typename std::set<PointerToAttribute > ::iterator i;
1676 for( i = m.edge_attr.begin(); i != m.edge_attr.end(); ++i)
1677 if( (*i)._handle == h._handle ){
1678 delete ((SimpleTempData<EdgeContainer,ATTR_TYPE>*)(*i)._handle);
1679 m.edge_attr.erase(i);
1687 bool DeletePerEdgeAttribute( MeshType & m, std::string name){
1689 PointerToAttribute h1; h1._name = name;
1690 i = m.edge_attr.find(h1);
1691 if(i==m.edge_attr.end())
return false;
1692 delete ((SimpleTempDataBase*)(*i)._handle);
1693 m.edge_attr.erase(i);
1698 template <
class ATTR_TYPE>
1700 bool IsValidHandle( MeshType & m,
const typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE> & a){
1701 if(a._handle == NULL)
return false;
1702 for(AttrIterator i = m.face_attr.begin(); i!=m.face_attr.end();++i)
1703 if ( (*i).n_attr == a.n_attr )
return true;
1707 template <
class ATTR_TYPE>
1709 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1710 AddPerFaceAttribute( MeshType & m, std::string name){
1712 PointerToAttribute h;
1715 i = m.face_attr.find(h);
1716 assert(i ==m.face_attr.end() );
1719 h._sizeof =
sizeof(ATTR_TYPE);
1721 h._handle =
new SimpleTempData<FaceContainer,ATTR_TYPE>(m.face);
1722 h._type =
typeid(ATTR_TYPE);
1725 std::pair < AttrIterator , bool> res = m.face_attr.insert(h);
1726 return typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
1729 template <
class ATTR_TYPE>
1731 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1732 AddPerFaceAttribute( MeshType & m){
1733 return AddPerFaceAttribute<ATTR_TYPE>(m,std::string(
""));
1740 template <
class ATTR_TYPE>
1742 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1744 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE> h;
1746 h = FindPerFaceAttribute<ATTR_TYPE>(m,name);
1747 if(IsValidHandle(m,h))
1750 return AddPerFaceAttribute<ATTR_TYPE>(m,name);
1753 template <
class ATTR_TYPE>
1755 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1756 FindPerFaceAttribute( MeshType & m,
const std::string & name){
1757 assert(!name.empty());
1758 PointerToAttribute h1; h1._name = name;
1759 typename std::set<PointerToAttribute > ::iterator i;
1761 i =m.face_attr.find(h1);
1762 if(i!=m.face_attr.end())
1763 if((*i)._sizeof ==
sizeof(ATTR_TYPE) ){
1764 if( (*i)._padding != 0 ){
1765 PointerToAttribute attr = (*i);
1766 m.face_attr.erase(i);
1767 FixPaddedPerFaceAttribute<ATTR_TYPE>(m,attr);
1768 std::pair<AttrIterator,bool> new_i = m.face_attr.insert(attr);
1769 assert(new_i.second);
1772 return typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1774 return typename MeshType:: template PerFaceAttributeHandle<ATTR_TYPE>(NULL,0);
1777 template <
class ATTR_TYPE>
1778 static void GetAllPerFaceAttribute(MeshType & m, std::vector<std::string> &all){
1780 typename std::set<PointerToAttribute > :: const_iterator i;
1781 for(i = m.face_attr.begin(); i != m.face_attr.end(); ++i )
1782 if(!(*i)._name.empty())
1784 typename MeshType:: template PerFaceAttributeHandle<ATTR_TYPE> hh;
1785 hh = Allocator<MeshType>:: template FindPerFaceAttribute <ATTR_TYPE>(m,(*i)._name);
1786 if(IsValidHandle<ATTR_TYPE>(m,hh))
1787 all.push_back((*i)._name);
1793 template <
class ATTR_TYPE>
1795 typename std::set<PointerToAttribute > ::iterator i;
1796 for( i = m.face_attr.begin(); i != m.face_attr.end(); ++i)
1797 if( (*i)._handle == h._handle ){
1798 delete ((SimpleTempData<FaceContainer,ATTR_TYPE>*)(*i)._handle);
1799 m.face_attr.erase(i);
1807 static bool DeletePerFaceAttribute( MeshType & m, std::string name){
1809 PointerToAttribute h1; h1._name = name;
1810 i = m.face_attr.find(h1);
1811 if(i==m.face_attr.end())
return false;
1812 delete ((SimpleTempDataBase*)(*i)._handle);
1813 m.face_attr.erase(i);
1818 template <
class ATTR_TYPE>
1819 static bool IsValidHandle(MeshType & m,
const typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> & a)
1821 if (a._handle == NULL)
1823 for (AttrIterator i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
1824 if ((*i).n_attr == a.n_attr)
1829 template <
class ATTR_TYPE>
1830 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> AddPerTetraAttribute(MeshType & m, std::string name)
1833 PointerToAttribute h;
1837 i = m.tetra_attr.find(h);
1838 assert(i == m.tetra_attr.end());
1841 h._sizeof =
sizeof(ATTR_TYPE);
1843 h._handle =
new SimpleTempData<TetraContainer, ATTR_TYPE>(m.tetra);
1844 h._type =
typeid(ATTR_TYPE);
1847 std::pair<AttrIterator, bool> res = m.tetra_attr.insert(h);
1848 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>(res.first->_handle, res.first->n_attr);
1851 template <
class ATTR_TYPE>
1852 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> AddPerTetraAttribute(MeshType &m)
1854 return AddPerTetraAttribute<ATTR_TYPE>(m, std::string(
""));
1861 template <
class ATTR_TYPE>
1862 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> GetPerTetraAttribute(MeshType &m, std::string name = std::string(
""))
1864 typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> h;
1867 h = FindPerTetraAttribute<ATTR_TYPE>(m, name);
1868 if (IsValidHandle(m, h))
1871 return AddPerTetraAttribute<ATTR_TYPE>(m, name);
1874 template <
class ATTR_TYPE>
1875 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> FindPerTetraAttribute(MeshType &m,
const std::string &name)
1877 assert(!name.empty());
1878 PointerToAttribute h1;
1880 typename std::set<PointerToAttribute>::iterator i;
1882 i = m.tetra_attr.find(h1);
1883 if (i != m.tetra_attr.end())
1884 if ((*i)._sizeof ==
sizeof(ATTR_TYPE))
1886 if ((*i)._padding != 0)
1888 PointerToAttribute attr = (*i);
1889 m.tetra_attr.erase(i);
1890 FixPaddedPerTetraAttribute<ATTR_TYPE>(m, attr);
1891 std::pair<AttrIterator, bool> new_i = m.tetra_attr.insert(attr);
1892 assert(new_i.second);
1895 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>((*i)._handle, (*i).n_attr);
1897 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>(NULL, 0);
1900 template <
class ATTR_TYPE>
1901 static void GetAllPerTetraAttribute(MeshType &m, std::vector<std::string> &all)
1904 typename std::set<PointerToAttribute>::const_iterator i;
1905 for (i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
1906 if (!(*i)._name.empty())
1908 typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> hh;
1909 hh = Allocator<MeshType>::template FindPerTetraAttribute<ATTR_TYPE>(m, (*i)._name);
1910 if (IsValidHandle<ATTR_TYPE>(m, hh))
1911 all.push_back((*i)._name);
1917 template <
class ATTR_TYPE>
1918 static void DeletePerTetraAttribute(MeshType &m,
typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> &h)
1920 typename std::set<PointerToAttribute>::iterator i;
1921 for (i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
1922 if ((*i)._handle == h._handle)
1924 delete ((SimpleTempData<TetraContainer, ATTR_TYPE> *)(*i)._handle);
1925 m.tetra_attr.erase(i);
1933 static bool DeletePerTetraAttribute(MeshType &m, std::string name)
1936 PointerToAttribute h1;
1938 i = m.tetra_attr.find(h1);
1939 if (i == m.tetra_attr.end())
1941 delete ((SimpleTempDataBase *)(*i)._handle);
1942 m.tetra_attr.erase(i);
1948 template <
class ATTR_TYPE>
1950 bool IsValidHandle( MeshType & m,
const typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE> & a){
1951 if(a._handle == NULL)
return false;
1952 for(AttrIterator i = m.mesh_attr.begin(); i!=m.mesh_attr.end();++i)
1953 if ( (*i).n_attr == a.n_attr )
return true;
1957 template <
class ATTR_TYPE>
1959 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
1960 AddPerMeshAttribute( MeshType & m, std::string name){
1962 PointerToAttribute h;
1965 i = m.mesh_attr.find(h);
1966 assert(i ==m.mesh_attr.end() );
1968 h._sizeof =
sizeof(ATTR_TYPE);
1970 h._handle =
new Attribute<ATTR_TYPE>();
1971 h._type =
typeid(ATTR_TYPE);
1974 std::pair < AttrIterator , bool> res = m.mesh_attr.insert(h);
1975 return typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
1982 template <
class ATTR_TYPE>
1984 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
1986 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE> h;
1988 h = FindPerMeshAttribute<ATTR_TYPE>(m,name);
1989 if(IsValidHandle(m,h))
1992 return AddPerMeshAttribute<ATTR_TYPE>(m,name);
1995 template <
class ATTR_TYPE>
1997 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
1998 FindPerMeshAttribute( MeshType & m,
const std::string & name){
1999 assert(!name.empty());
2000 PointerToAttribute h1; h1._name = name;
2001 typename std::set<PointerToAttribute > ::iterator i;
2003 i =m.mesh_attr.find(h1);
2004 if(i!=m.mesh_attr.end())
2005 if((*i)._sizeof ==
sizeof(ATTR_TYPE) ){
2006 if( (*i)._padding != 0 ){
2007 PointerToAttribute attr = (*i);
2008 m.mesh_attr.erase(i);
2009 FixPaddedPerMeshAttribute<ATTR_TYPE>(m,attr);
2010 std::pair<AttrIterator,bool> new_i = m.mesh_attr.insert(attr);
2011 assert(new_i.second);
2015 return typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
2018 return typename MeshType:: template PerMeshAttributeHandle<ATTR_TYPE>(NULL,0);
2021 template <
class ATTR_TYPE>
2022 static void GetAllPerMeshAttribute(
const MeshType & m, std::vector<std::string> &all){
2023 typename std::set<PointerToAttribute > :: iterator i;
2024 for(i = m.mesh_attr.begin(); i != m.mesh_attr.end(); ++i )
2025 if((*i)._sizeof ==
sizeof(ATTR_TYPE))
2026 all.push_back((*i)._name);
2031 template <
class ATTR_TYPE>
2033 typename std::set<PointerToAttribute > ::iterator i;
2034 for( i = m.mesh_attr.begin(); i != m.mesh_attr.end(); ++i)
2035 if( (*i)._handle == h._handle ){
2036 delete (( Attribute<ATTR_TYPE> *)(*i)._handle);
2037 m.mesh_attr.erase(i);
2044 static bool DeletePerMeshAttribute( MeshType & m, std::string name){
2046 PointerToAttribute h1; h1._name = name;
2047 i = m.mesh_attr.find(h1);
2048 if (i==m.mesh_attr.end())
2050 delete ((SimpleTempDataBase *)(*i)._handle);
2051 m.mesh_attr.erase(i);
2055 template <
class ATTR_TYPE>
2056 static void FixPaddedPerVertexAttribute (MeshType & m, PointerToAttribute & pa){
2059 SimpleTempData<VertContainer,ATTR_TYPE>* _handle =
new SimpleTempData<VertContainer,ATTR_TYPE>(m.vert);
2062 _handle->Resize(m.vert.size());
2063 for(
size_t i = 0; i < m.vert.size(); ++i){
2064 ATTR_TYPE * dest = &(*_handle)[i];
2065 char * ptr = (
char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2066 memcpy((
void*)dest ,
2067 (
void*) &(ptr[i * pa._sizeof ]) ,
sizeof(ATTR_TYPE));
2071 delete ((SimpleTempDataBase*) pa._handle);
2074 pa._sizeof =
sizeof(ATTR_TYPE);
2077 pa._handle = _handle;
2082 template <
class ATTR_TYPE>
2083 static void FixPaddedPerEdgeAttribute (MeshType & m, PointerToAttribute & pa){
2086 SimpleTempData<EdgeContainer,ATTR_TYPE>* _handle =
new SimpleTempData<EdgeContainer,ATTR_TYPE>(m.edge);
2089 _handle->Resize(m.edge.size());
2090 for(
size_t i = 0; i < m.edge.size(); ++i){
2091 ATTR_TYPE * dest = &(*_handle)[i];
2092 char * ptr = (
char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2093 memcpy((
void*)dest ,
2094 (
void*) &(ptr[i * pa._sizeof ]) ,
sizeof(ATTR_TYPE));
2098 delete ((SimpleTempDataBase*) pa._handle);
2101 pa._sizeof =
sizeof(ATTR_TYPE);
2104 pa._handle = _handle;
2110 template <
class ATTR_TYPE>
2111 static void FixPaddedPerFaceAttribute ( MeshType & m,PointerToAttribute & pa){
2114 SimpleTempData<FaceContainer,ATTR_TYPE>* _handle =
new SimpleTempData<FaceContainer,ATTR_TYPE>(m.face);
2117 _handle->Resize(m.face.size());
2118 for(
size_t i = 0; i < m.face.size(); ++i){
2119 ATTR_TYPE * dest = &(*_handle)[i];
2120 char * ptr = (
char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2121 memcpy((
void*)dest ,
2122 (
void*) &(ptr[i * pa._sizeof ]) ,
sizeof(ATTR_TYPE));
2126 delete ((SimpleTempDataBase*) pa._handle);
2129 pa._sizeof =
sizeof(ATTR_TYPE);
2132 pa._handle = _handle;
2138 template <
class ATTR_TYPE>
2139 static void FixPaddedPerTetraAttribute(MeshType &m, PointerToAttribute &pa)
2143 SimpleTempData<TetraContainer, ATTR_TYPE> *_handle =
new SimpleTempData<TetraContainer, ATTR_TYPE>(m.tetra);
2146 _handle->Resize(m.tetra.size());
2147 for (
size_t i = 0; i < m.tetra.size(); ++i)
2149 ATTR_TYPE *dest = &(*_handle)[i];
2150 char *ptr = (
char *)(((SimpleTempDataBase *)pa._handle)->DataBegin());
2151 memcpy((
void *)dest,
2152 (
void *)&(ptr[i * pa._sizeof]),
sizeof(ATTR_TYPE));
2156 delete ((SimpleTempDataBase *)pa._handle);
2159 pa._sizeof =
sizeof(ATTR_TYPE);
2162 pa._handle = _handle;
2168 template <
class ATTR_TYPE>
2169 static void FixPaddedPerMeshAttribute ( MeshType & ,PointerToAttribute & pa){
2172 Attribute<ATTR_TYPE> * _handle =
new Attribute<ATTR_TYPE>();
2175 char * ptr = (
char*)( ((Attribute<ATTR_TYPE> *)pa._handle)->DataBegin());
2176 memcpy((
void*)_handle->attribute ,(
void*) &(ptr[0]) ,
sizeof(ATTR_TYPE));
2179 delete ( (Attribute<ATTR_TYPE> *) pa._handle);
2182 pa._sizeof =
sizeof(ATTR_TYPE);
2185 pa._handle = _handle;