VCG Library
Loading...
Searching...
No Matches
allocate.h
1/***************************************************************************
2* VCGLib o o *
3* Visual and Computer Graphics Library o o *
4* _ O _ *
5* Copyright(C) 2004-2016 \/)\/ *
6* Visual Computing Lab /\/| *
7* ISTI - Italian National Research Council | *
8* \ *
9* All rights reserved. *
10* *
11* This program is free software; you can redistribute it and/or modify *
12* it under the terms of the GNU General Public License as published by *
13* the Free Software Foundation; either version 2 of the License, or *
14* (at your option) any later version. *
15* *
16* This program is distributed in the hope that it will be useful, *
17* but WITHOUT ANY WARRANTY; without even the implied warranty of *
18* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
20* for more details. *
21* *
22****************************************************************************/
23#ifndef __VCGLIB_TRIALLOCATOR
24#define __VCGLIB_TRIALLOCATOR
25
26#include <vector>
27#include <set>
28
29#include <vcg/container/simple_temporary_data.h>
30
31#include "used_types.h"
32
33namespace vcg {
34namespace tri {
39template<class MeshType>
40size_t Index(const MeshType &m, const typename MeshType::VertexType &v) {return &v-&*m.vert.begin();}
41template<class MeshType>
42size_t Index(const MeshType &m, const typename MeshType::FaceType &f) {return &f-&*m.face.begin();}
43template<class MeshType>
44size_t Index(const MeshType &m, const typename MeshType::EdgeType &e) {return &e-&*m.edge.begin();}
45template<class MeshType>
46size_t Index(const MeshType &m, const typename MeshType::HEdgeType &h) {return &h-&*m.hedge.begin();}
47template <class MeshType>
48size_t Index(const MeshType &m, const typename MeshType::TetraType &t) { return &t - &*m.tetra.begin(); }
49
50
51template<class MeshType>
52size_t Index(const MeshType &m, const typename MeshType::VertexType *vp) {return vp-&*m.vert.begin();}
53template<class MeshType>
54size_t Index(const MeshType &m, const typename MeshType::FaceType * fp) {return fp-&*m.face.begin();}
55template<class MeshType>
56size_t Index(const MeshType &m, const typename MeshType::EdgeType* e) {return e-&*m.edge.begin();}
57template<class MeshType>
58size_t Index(const MeshType &m, const typename MeshType::HEdgeType* h) {return h-&*m.hedge.begin();}
59template <class MeshType>
60size_t Index(const MeshType &m, const typename MeshType::TetraType *t) { return t - &*m.tetra.begin(); }
61
62
63template<class MeshType>
64bool IsValidPointer( MeshType & m, const typename MeshType::VertexType *vp) { return ( m.vert.size() > 0 && (vp >= &*m.vert.begin()) && (vp <= &m.vert.back()) ); }
65template<class MeshType>
66bool IsValidPointer(MeshType & m, const typename MeshType::EdgeType *ep) { return ( m.edge.size() > 0 && (ep >= &*m.edge.begin()) && (ep <= &m.edge.back())); }
67template<class MeshType>
68bool IsValidPointer(MeshType & m, const typename MeshType::FaceType *fp) { return ( m.face.size() > 0 && (fp >= &*m.face.begin()) && (fp <= &m.face.back())); }
69template<class MeshType>
70bool IsValidPointer(MeshType & m, const typename MeshType::HEdgeType *hp) { return ( m.hedge.size() > 0 && (hp >= &*m.hedge.begin()) && (hp <= &m.hedge.back())); }
71template <class MeshType>
72bool IsValidPointer(MeshType &m, const typename MeshType::TetraType *tp) { return (m.tetra.size() > 0 && (tp >= &*m.tetra.begin()) && (tp <= &m.tetra.back())); }
73
74template <class MeshType, class ATTR_CONT>
75void ReorderAttribute(ATTR_CONT &c, std::vector<size_t> & newVertIndex, MeshType & /* m */){
76 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
77 for(ai = c.begin(); ai != c.end(); ++ai)
78 ((typename MeshType::PointerToAttribute)(*ai)).Reorder(newVertIndex);
79}
80
81template <class MeshType, class ATTR_CONT>
82void ResizeAttribute(ATTR_CONT &c, size_t sz, MeshType &/*m*/){
83 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
84 for(ai =c.begin(); ai != c.end(); ++ai)
85 ((typename MeshType::PointerToAttribute)(*ai)).Resize(sz);
86}
87
95template <class MeshType>
96class Allocator
97{
98
99public:
100 typedef typename MeshType::VertexType VertexType;
101 typedef typename MeshType::VertexPointer VertexPointer;
102 typedef typename MeshType::VertexIterator VertexIterator;
103 typedef typename MeshType::VertContainer VertContainer;
104
105 typedef typename MeshType::EdgeType EdgeType;
106 typedef typename MeshType::EdgePointer EdgePointer;
107 typedef typename MeshType::EdgeIterator EdgeIterator;
108 typedef typename MeshType::EdgeContainer EdgeContainer;
109
110 typedef typename MeshType::FaceType FaceType;
111 typedef typename MeshType::FacePointer FacePointer;
112 typedef typename MeshType::FaceIterator FaceIterator;
113 typedef typename MeshType::FaceContainer FaceContainer;
114
115 typedef typename MeshType::HEdgeType HEdgeType;
116 typedef typename MeshType::HEdgePointer HEdgePointer;
117 typedef typename MeshType::HEdgeIterator HEdgeIterator;
118 typedef typename MeshType::HEdgeContainer HEdgeContainer;
119
120 typedef typename MeshType::TetraType TetraType;
121 typedef typename MeshType::TetraPointer TetraPointer;
122 typedef typename MeshType::TetraIterator TetraIterator;
123 typedef typename MeshType::TetraContainer TetraContainer;
124
125 typedef typename MeshType::CoordType CoordType;
126
127 typedef typename MeshType::PointerToAttribute PointerToAttribute;
128 typedef typename std::set<PointerToAttribute>::iterator AttrIterator;
129 typedef typename std::set<PointerToAttribute>::const_iterator AttrConstIterator;
130 typedef typename std::set<PointerToAttribute >::iterator PAIte;
131
143 template<class SimplexPointerType>
144 class PointerUpdater
145 {
146 public:
147 PointerUpdater(void) : newBase(0), oldBase(0), newEnd(0), oldEnd(0), preventUpdateFlag(false) { ; }
148 void Clear(){newBase=oldBase=newEnd=oldEnd=0; remap.clear();}
153 void Update(SimplexPointerType &vp)
154 {
155 //if(vp>=newBase && vp<newEnd) return;
156 if(vp<oldBase || vp>oldEnd) return;
157 assert(vp>=oldBase);
158 assert(vp<oldEnd);
159 vp=newBase+(vp-oldBase);
160 if(!remap.empty())
161 {
162 // A compaction leaves no slot for a deleted element (its remap entry is the max
163 // value), so a pointer still aiming at one -- stale adjacency -- becomes null
164 // instead of overflowing into garbage.
165 const size_t r = remap[vp-newBase];
166 vp = (r == std::numeric_limits<size_t>::max()) ? nullptr : newBase + r;
167 }
168 }
172 bool NeedUpdate() {if((oldBase && newBase!=oldBase && !preventUpdateFlag) || !remap.empty()) return true; else return false;}
173
174 SimplexPointerType newBase;
175 SimplexPointerType oldBase;
176 SimplexPointerType newEnd;
177 SimplexPointerType oldEnd;
178 std::vector<size_t> remap; // this vector keep the new position of an element. Uninitialized elements have max_int value to denote an element that has not to be remapped.
179
180 bool preventUpdateFlag;
181 };
182
183 /* +++++++++++++++ Add Vertices ++++++++++++++++ */
184
195 static VertexIterator AddVertices(MeshType &m, size_t n, PointerUpdater<VertexPointer> &pu)
196 {
197 VertexIterator last;
198 if(n == 0)
199 return m.vert.end();
200 pu.Clear();
201
202 if(m.vert.empty())
203 pu.oldBase=0; // if the vector is empty we cannot find the last valid element
204 else {
205 pu.oldBase=&*m.vert.begin();
206 pu.oldEnd=&m.vert.back()+1;
207 }
208
209 m.vert.resize(m.vert.size()+n);
210 m.vn+=int(n);
211
212 typename std::set<PointerToAttribute>::iterator ai;
213 for(ai = m.vert_attr.begin(); ai != m.vert_attr.end(); ++ai)
214 ((PointerToAttribute)(*ai)).Resize(m.vert.size());
215
216 pu.newBase = &*m.vert.begin();
217 pu.newEnd = &m.vert.back()+1;
218 if(pu.NeedUpdate())
219 {
220 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi)
221 if(!(*fi).IsD())
222 for(int i=0; i < (*fi).VN(); ++i)
223 if ((*fi).cV(i)!=0) pu.Update((*fi).V(i));
224
225 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
226 if(!(*ei).IsD())
227 {
228 // if(HasEVAdjacency (m))
229 pu.Update((*ei).V(0));
230 pu.Update((*ei).V(1));
231 // if(HasEVAdjacency(m)) pu.Update((*ei).EVp());
232 }
233
234 HEdgeIterator hi;
235 for (hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
236 if(!(*hi).IsD())
237 {
238 if(HasHVAdjacency (m))
239 {
240 pu.Update((*hi).HVp());
241 }
242 }
243
244 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
245 if (!(*ti).IsD())
246 for (int i = 0; i < 4; ++i)
247 if ((*ti).cV(i) != 0)
248 pu.Update((*ti).V(i));
249
250 // e poiche' lo spazio e' cambiato si ricalcola anche last da zero
251 }
252 size_t siz=(size_t)(m.vert.size()-n);
253
254 last = m.vert.begin();
255 advance(last,siz);
256
257 return last;// deve restituire l'iteratore alla prima faccia aggiunta;
258 }
259
262 static VertexIterator AddVertices(MeshType &m, size_t n)
263 {
264 PointerUpdater<VertexPointer> pu;
265 return AddVertices(m, n,pu);
266 }
267
270 static VertexIterator AddVertices(MeshType &m, size_t n, std::vector<VertexPointer *> &local_vec)
271 {
272 PointerUpdater<VertexPointer> pu;
273 VertexIterator v_ret = AddVertices(m, n,pu);
274
275 typename std::vector<VertexPointer *>::iterator vi;
276 for(vi=local_vec.begin();vi!=local_vec.end();++vi)
277 pu.Update(**vi);
278 return v_ret;
279 }
280
284 static VertexIterator AddVertices(MeshType &m, const Eigen::MatrixXf &vm)
285 {
286 VertexIterator v_ret = AddVertices(m, vm.rows());
287 VertexIterator v_start = v_ret;
288 for(int i=0;i<vm.rows();++i)
289 {
290 v_ret->P()[0]=vm(i,0);
291 v_ret->P()[1]=vm(i,1);
292 v_ret->P()[2]=vm(i,2);
293 ++v_ret;
294 }
295 return v_start;
296 }
297
298
301 static VertexIterator AddVertex(MeshType &m, const CoordType &p)
302 {
303 VertexIterator v_ret = AddVertices(m, 1);
304 v_ret->P()=p;
305 return v_ret;
306 }
307
310 static VertexIterator AddVertex(MeshType &m, const CoordType &p, const CoordType &n)
311 {
312 VertexIterator v_ret = AddVertices(m, 1);
313 v_ret->P()=p;
314 v_ret->N()=n;
315 return v_ret;
316 }
317
320 static VertexIterator AddVertex(MeshType &m, const CoordType &p, const Color4b &c)
321 {
322 VertexIterator v_ret = AddVertices(m, 1);
323 v_ret->P()=p;
324 v_ret->C()=c;
325 return v_ret;
326 }
327
328 /* +++++++++++++++ Add Edges ++++++++++++++++ */
329
339 static EdgeIterator AddEdges(MeshType &m, size_t n, PointerUpdater<EdgePointer> &pu)
340 {
341 if(n == 0) return m.edge.end();
342 pu.Clear();
343 if(m.edge.empty()) pu.oldBase=0; // if the vector is empty we cannot find the last valid element
344 else {
345 pu.oldBase=&*m.edge.begin();
346 pu.oldEnd=&m.edge.back()+1;
347 }
348
349 m.edge.resize(m.edge.size()+n);
350 m.en+=int(n);
351 size_t siz=(size_t)(m.edge.size()-n);
352 EdgeIterator firstNewEdge = m.edge.begin();
353 advance(firstNewEdge,siz);
354
355 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
356 for(ai = m.edge_attr.begin(); ai != m.edge_attr.end(); ++ai)
357 ((typename MeshType::PointerToAttribute)(*ai)).Resize(m.edge.size());
358
359 pu.newBase = &*m.edge.begin();
360 pu.newEnd = &m.edge.back()+1;
361 if(pu.NeedUpdate())
362 {
363 if(HasFEAdjacency(m))
364 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi){
365 if(!(*fi).IsD())
366 for(int i=0; i < (*fi).VN(); ++i)
367 if ((*fi).cFEp(i)!=0) pu.Update((*fi).FEp(i));
368 }
369
370 if(HasVEAdjacency(m)){
371 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
372 if(!(*vi).IsD())
373 if ((*vi).cVEp()!=0) pu.Update((*vi).VEp());
374 for(EdgeIterator ei=m.edge.begin();ei!=firstNewEdge;++ei)
375 if(!(*ei).IsD())
376 {
377 if ((*ei).cVEp(0)!=0) pu.Update((*ei).VEp(0));
378 if ((*ei).cVEp(1)!=0) pu.Update((*ei).VEp(1));
379 }
380 }
381
382 if(HasHEAdjacency(m))
383 for (HEdgeIterator hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
384 if(!(*hi).IsD())
385 if ((*hi).cHEp()!=0) pu.Update((*hi).HEp());
386 }
387
388 return firstNewEdge;// deve restituire l'iteratore alla prima faccia aggiunta;
389 }
390
393 static EdgeIterator AddEdge(MeshType &m, VertexPointer v0, VertexPointer v1)
394 {
395 EdgeIterator ei= AddEdges(m, 1);
396 ei->V(0)=v0;
397 ei->V(1)=v1;
398 return ei;
399 }
400
403 static EdgeIterator AddEdge(MeshType &m, size_t v0, size_t v1)
404 {
405 assert(v0!=v1);
406 assert(v0>=0 && v0<m.vert.size());
407 assert(v1>=0 && v1<m.vert.size());
408 return AddEdge(m,&(m.vert[v0]),&(m.vert[v1]));
409 }
410
411
414 static EdgeIterator AddEdge(MeshType &m, CoordType p0, CoordType p1)
415 {
416 VertexIterator vi = AddVertices(m,2);
417 EdgeIterator ei = AddEdges(m,1);
418 vi->P()=p0;
419 ei->V(0)=&*vi++;
420 vi->P()=p1;
421 ei->V(1)=&*vi++;
422 return ei;
423 }
424
428 static EdgeIterator AddEdges(MeshType &m, size_t n)
429 {
430 PointerUpdater<EdgePointer> pu;
431 return AddEdges(m, n,pu);
432 }
433
437 static EdgeIterator AddEdges(MeshType &m, size_t n, std::vector<EdgePointer*> &local_vec)
438 {
439 PointerUpdater<EdgePointer> pu;
440 EdgeIterator v_ret = AddEdges(m, n,pu);
441
442 typename std::vector<EdgePointer *>::iterator ei;
443 for(ei=local_vec.begin();ei!=local_vec.end();++ei)
444 pu.Update(**ei);
445 return v_ret;
446 }
447
448 /* +++++++++++++++ Add HalfEdges ++++++++++++++++ */
449
459 static HEdgeIterator AddHEdges(MeshType &m, size_t n, PointerUpdater<HEdgePointer> &pu)
460 {
461 HEdgeIterator last;
462 if(n == 0) return m.hedge.end();
463 pu.Clear();
464 if(m.hedge.empty()) pu.oldBase=0; // if the vector is empty we cannot find the last valid element
465 else {
466 pu.oldBase=&*m.hedge.begin();
467 pu.oldEnd=&m.hedge.back()+1;
468 }
469
470 m.hedge.resize(m.hedge.size()+n);
471 m.hn+=int(n);
472
473 pu.newBase = &*m.hedge.begin();
474 pu.newEnd = &m.hedge.back()+1;
475
476 if(pu.NeedUpdate())
477 {
478 if(HasFHAdjacency(m)) {
479 for (FaceIterator fi=m.face.begin(); fi!=m.face.end(); ++fi)
480 {
481 if(!(*fi).IsD() && (*fi).FHp())
482 pu.Update((*fi).FHp());
483 }
484 }
485 if(HasVHAdjacency(m)) {
486 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
487 if(!(*vi).IsD() && (*vi).cVHp()!=0)
488 pu.Update((*vi).VHp());
489 }
490 if(HasEHAdjacency(m)) {
491 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
492 if(!(*ei).IsD() && (*ei).cEHp()!=0)
493 pu.Update((*ei).EHp());
494 }
495
496 int ii = 0;
497 HEdgeIterator hi = m.hedge.begin();
498 while(ii < m.hn - int(n))// cycle on all the faces except the new ones
499 {
500 if(!(*hi).IsD())
501 {
502 if(HasHNextAdjacency(m)) pu.Update((*hi).HNp());
503 if(HasHPrevAdjacency(m)) pu.Update((*hi).HPp());
504 if(HasHOppAdjacency(m)) pu.Update((*hi).HOp());
505 ++ii;
506 }
507 ++hi;
508 }
509 }
510 size_t siz = (size_t)(m.hedge.size()-n);
511
512 last = m.hedge.begin();
513 advance(last,siz);
514
515 return last;// deve restituire l'iteratore alla prima faccia aggiunta;
516 }
517
521 static HEdgeIterator AddHEdges(MeshType &m, size_t n)
522 {
523 PointerUpdater<HEdgePointer> pu;
524 return AddHEdges(m, n,pu);
525 }
526
530 static HEdgeIterator AddHEdges(MeshType &m, size_t n, std::vector<HEdgePointer*> &local_vec)
531 {
532 PointerUpdater<HEdgePointer> pu;
533 HEdgeIterator v_ret = AddHEdges(m, n,pu);
534
535 typename std::vector<HEdgePointer *>::iterator ei;
536 for(ei=local_vec.begin();ei!=local_vec.end();++ei)
537 pu.Update(**ei);
538 return v_ret;
539 }
540
541 /* +++++++++++++++ Add Faces ++++++++++++++++ */
542
545 static FaceIterator AddFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2)
546 {
547 assert(m.vert.size()>0);
548 assert((v0!=v1) && (v1!=v2) && (v0!=v2));
549 assert(v0>=&m.vert.front() && v0<=&m.vert.back());
550 assert(v1>=&m.vert.front() && v1<=&m.vert.back());
551 assert(v2>=&m.vert.front() && v2<=&m.vert.back());
552 PointerUpdater<FacePointer> pu;
553 FaceIterator fi = AddFaces(m,1,pu);
554 fi->Alloc(3);
555 fi->V(0)=v0;
556 fi->V(1)=v1;
557 fi->V(2)=v2;
558 return fi;
559 }
560
563 static FaceIterator AddFace(MeshType &m, size_t v0, size_t v1, size_t v2)
564 {
565 assert((v0!=v1) && (v1!=v2) && (v0!=v2));
566 assert(v0>=0 && v0<m.vert.size());
567 assert(v1>=0 && v1<m.vert.size());
568 assert(v2>=0 && v2<m.vert.size());
569 return AddFace(m,&(m.vert[v0]),&(m.vert[v1]),&(m.vert[v2]));
570 }
573 static FaceIterator AddFace(MeshType &m, CoordType p0, CoordType p1, CoordType p2)
574 {
575 VertexIterator vi = AddVertices(m,3);
576 FaceIterator fi = AddFaces(m,1);
577 fi->Alloc(3);
578 vi->P()=p0;
579 fi->V(0)=&*vi++;
580 vi->P()=p1;
581 fi->V(1)=&*vi++;
582 vi->P()=p2;
583 fi->V(2)=&*vi;
584 return fi;
585 }
586
591 static FaceIterator AddQuadFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
592 {
593 assert(m.vert.size()>0);
594 assert(v0>=&m.vert.front() && v0<=&m.vert.back());
595 assert(v1>=&m.vert.front() && v1<=&m.vert.back());
596 assert(v2>=&m.vert.front() && v2<=&m.vert.back());
597 assert(v3>=&m.vert.front() && v3<=&m.vert.back());
598 PointerUpdater<FacePointer> pu;
599 if(FaceType::HasPolyInfo())
600 {
601 FaceIterator fi = AddFaces(m,1,pu);
602 fi->Alloc(4);
603 fi->V(0)=v0; fi->V(1)=v1;
604 fi->V(2)=v2; fi->V(3)=v3;
605 return fi;
606 }
607 else
608 {
609 FaceIterator fi = AddFaces(m,2,pu);
610 fi->Alloc(3); fi->V(0)=v0; fi->V(1)=v1; fi->V(2)=v2;
611 fi->SetF(2);
612 ++fi;
613 fi->Alloc(3); fi->V(0)=v0; fi->V(1)=v2; fi->V(2)=v3;
614 fi->SetF(0);
615 return fi;
616 }
617 }
621 static FaceIterator AddFaces(MeshType &m, size_t n)
622 {
623 PointerUpdater<FacePointer> pu;
624 return AddFaces(m,n,pu);
625 }
626
630 static FaceIterator AddFaces(MeshType &m, size_t n,std::vector<FacePointer *> &local_vec)
631 {
632 PointerUpdater<FacePointer> pu;
633 FaceIterator f_ret= AddFaces(m,n,pu);
634
635 typename std::vector<FacePointer *>::iterator fi;
636 for(fi=local_vec.begin();fi!=local_vec.end();++fi)
637 pu.Update(**fi);
638 return f_ret;
639 }
640
644 static FaceIterator AddFaces(MeshType &m, const Eigen::MatrixXi &fm)
645 {
646 PointerUpdater<FacePointer> pu;
647 FaceIterator f_start = AddFaces(m,fm.rows(),pu);
648 FaceIterator f_ret=f_start;
649 for(int i=0;i<fm.rows();++i)
650 {
651 f_start->V(0)= &m.vert[fm(i,0)];
652 f_start->V(1)= &m.vert[fm(i,1)];
653 f_start->V(2)= &m.vert[fm(i,2)];
654 ++f_start;
655 }
656 return f_ret;
657 }
658
671 static FaceIterator AddFaces(MeshType &m, size_t n, PointerUpdater<FacePointer> &pu)
672 {
673 pu.Clear();
674 if(n == 0) return m.face.end();
675 if(!m.face.empty()) // if the vector is empty we cannot find the last valid element
676 {
677 pu.oldBase=&*m.face.begin();
678 pu.oldEnd=&m.face.back()+1;
679 }
680 // The actual resize
681 m.face.resize(m.face.size()+n);
682 m.fn+=int(n);
683
684 size_t siz=(size_t)(m.face.size()-n);
685 FaceIterator firstNewFace = m.face.begin();
686 advance(firstNewFace,siz);
687
688 typename std::set<PointerToAttribute>::iterator ai;
689 for(ai = m.face_attr.begin(); ai != m.face_attr.end(); ++ai)
690 ((PointerToAttribute)(*ai)).Resize(m.face.size());
691
692 pu.newBase = &*m.face.begin();
693 pu.newEnd = &m.face.back()+1;
694
695 if(pu.NeedUpdate())
696 {
697 if(HasFFAdjacency(m))
698 { // cycle on all the faces except the new ones
699 for(FaceIterator fi=m.face.begin();fi!=firstNewFace;++fi)
700 if(!(*fi).IsD())
701 for(int i = 0; i < (*fi).VN(); ++i)
702 if ((*fi).cFFp(i)!=0) pu.Update((*fi).FFp(i));
703 }
704
705 if(HasPerVertexVFAdjacency(m) && HasPerFaceVFAdjacency(m))
706 { // cycle on all the faces except the new ones
707 for(FaceIterator fi=m.face.begin();fi!=firstNewFace;++fi)
708 if(!(*fi).IsD())
709 for(int i = 0; i < (*fi).VN(); ++i)
710 if ((*fi).cVFp(i)!=0) pu.Update((*fi).VFp(i));
711
712 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
713 if(!(*vi).IsD() && (*vi).cVFp()!=0)
714 pu.Update((*vi).VFp());
715 }
716
717 if(HasEFAdjacency(m))
718 {
719 for (EdgeIterator ei=m.edge.begin(); ei!=m.edge.end(); ++ei)
720 if(!(*ei).IsD() && (*ei).cEFp()!=0)
721 pu.Update((*ei).EFp());
722 }
723
724 if(HasHFAdjacency(m))
725 {
726 for (HEdgeIterator hi=m.hedge.begin(); hi!=m.hedge.end(); ++hi)
727 if(!(*hi).IsD() && (*hi).cHFp()!=0)
728 pu.Update((*hi).HFp());
729 }
730 }
731 return firstNewFace;
732 }
733
734 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
735 //:::::::::::::::::TETRAS ADDER FUNCTIONS:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
736
749 static TetraIterator AddTetras(MeshType &m, size_t n, PointerUpdater<TetraPointer> &pu)
750 {
751 //nothing to do
752 if (n == 0)
753 return m.tetra.end();
754
755 //prepare the pointerupdater info
756 pu.Clear();
757 if (m.tetra.empty())
758 pu.oldBase = 0;
759 else
760 {
761 pu.oldBase = &*m.tetra.begin();
762 pu.oldEnd = &m.tetra.back() + 1;
763 }
764
765 //resize the tetra list and update tetra count
766 m.tetra.resize(m.tetra.size() + n);
767 m.tn += n;
768
769 //get the old size and advance to the first new tetrahedron position
770 size_t oldSize = (size_t)(m.tetra.size() - n);
771
772 TetraIterator firstNewTetra = m.tetra.begin();
773 advance(firstNewTetra, oldSize);
774
775 //for each attribute make adapt the list size
776 typename std::set<typename MeshType::PointerToAttribute>::iterator ai;
777 for (ai = m.tetra_attr.begin(); ai != m.tetra_attr.end(); ++ai)
778 ((typename MeshType::PointerToAttribute)(*ai)).Resize(m.tetra.size());
779
780 //do the update
781 pu.newBase = &*m.tetra.begin();
782 pu.newEnd = &m.tetra.back() + 1;
783 if (pu.NeedUpdate())
784 {
785 if (HasVTAdjacency(m))
786 {
787 for (VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
788 if (!vi->IsD())
789 pu.Update(vi->VTp());
790
791 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
792 if (!ti->IsD())
793 {
794 pu.Update(ti->VTp(0));
795 pu.Update(ti->VTp(1));
796 pu.Update(ti->VTp(2));
797 pu.Update(ti->VTp(3));
798 }
799 }
800
801 //do edge and face adjacency
802 if (HasTTAdjacency(m))
803 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
804 if (!ti->IsD())
805 {
806 pu.Update(ti->TTp(0));
807 pu.Update(ti->TTp(1));
808 pu.Update(ti->TTp(2));
809 pu.Update(ti->TTp(3));
810 }
811 }
812
813 return firstNewTetra;
814 }
815
816//TODO: ADD 4 FACES then add tetra
819 static TetraIterator AddTetra(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
820 {
821 assert(m.vert.size() > 0);
822 assert((v0 != v1) && (v0 != v2) && (v0 != v3) && (v1 != v2) && (v1 != v3) && (v2 != v3));
823 assert(v0 >= &m.vert.front() && v0 <= &m.vert.back());
824 assert(v1 >= &m.vert.front() && v1 <= &m.vert.back());
825 assert(v2 >= &m.vert.front() && v2 <= &m.vert.back());
826 assert(v3 >= &m.vert.front() && v3 <= &m.vert.back());
827
828// AddFace(m, v0, v1, v2);
829// AddFace(m, v0, v3, v1);
830// AddFace(m, v0, v2, v3);
831// AddFace(m, v1, v3, v2);
832
833 PointerUpdater<TetraPointer> pu;
834 TetraIterator ti = AddTetras(m, 1, pu);
835 ti->V(0) = v0;
836 ti->V(1) = v1;
837 ti->V(2) = v2;
838 ti->V(3) = v3;
839 return ti;
840 }
841
844 static TetraIterator AddTetra(MeshType &m, const size_t v0, const size_t v1, const size_t v2, const size_t v3)
845 {
846 assert(m.vert.size() > 0);
847 assert((v0 != v1) && (v0 != v2) && (v0 != v3) && (v1 != v2) && (v1 != v3) && (v2 != v3));
848 assert(v0 >= 0 && v0 < m.vert.size());
849 assert(v1 >= 0 && v1 < m.vert.size());
850 assert(v2 >= 0 && v2 < m.vert.size());
851 assert(v3 >= 0 && v3 < m.vert.size());
852
853 return AddTetra(m, &(m.vert[v0]), &(m.vert[v1]), &(m.vert[v2]), &(m.vert[v3]));
854 }
857 static TetraIterator AddTetra(MeshType &m, const CoordType & p0, const CoordType & p1, const CoordType & p2, const CoordType & p3)
858 {
859 VertexIterator vi = AddVertices(m, 4);
860
861 VertexPointer v0 = &*vi++;
862 VertexPointer v1 = &*vi++;
863 VertexPointer v2 = &*vi++;
864 VertexPointer v3 = &*vi++;
865
866 v0->P() = p0;
867 v1->P() = p1;
868 v2->P() = p2;
869 v3->P() = p3;
870
871 return AddTetra(m, v0, v1, v2, v3);
872 }
873
874// //requires no duplicate vertices on faces you use
875// static TetraIterator AddTetra(MeshType &m, const FaceType & f0, const FaceType & f1, const FaceType & f2, const FaceType & f3)
876// {
877// assert(m.face.size() > 0);
878// assert((f0 != f1) && (f0 != f2) && (f0 != f3) && (f1 != f2) && (f1 != f3) && (f2 != f3));
879// assert(f1 >= 0 && f1 < m.face.size());
880// assert(f2 >= 0 && f2 < m.face.size());
881// assert(f3 >= 0 && f3 < m.face.size());
882// assert(f0 >= 0 && f0 < m.face.size());
883// //TODO: decide if you want to address this like this
884// //ERROR: can't use position...so..could force to have no dup verts..and use pointers or avoid this kind of thing
885// assert(f0.V(0) == f1.V(0) && f0.V(0) == f2.V(0) && //v0
886// f0.V(1) == f1.V(2) && f0.V(1) == f3.V(0) && //v1
887// f0.V(2) == f2.V(1) && f0.V(2) == f3.V(2) && //v2
888// f1.V(1) == f2.V(2) && f1.V(1) == f3.V(1) ) //v3
889
890// //add a tetra...and set vertices correctly
891// PointerUpdater<TetraPointer> pu;
892// TetraIterator ti = AddTetras(m, 1, pu);
893// ti->V(0) = f0.V(0);
894// ti->V(1) = f0.V(1);
895// ti->V(2) = f0.V(2);
896// ti->V(3) = f1.V(1);
897
898// return ti;
899// }
900
904 static TetraIterator AddTetras(MeshType &m, size_t n)
905 {
906 PointerUpdater<TetraPointer> pu;
907 return AddTetras(m, n, pu);
908 }
909
913 static TetraIterator AddTetras(MeshType &m, size_t n, std::vector<TetraPointer *> &local_vec)
914 {
915 PointerUpdater<TetraPointer> pu;
916 TetraIterator t_ret = AddTetras(m, n, pu);
917
918 typename std::vector<TetraPointer *>::iterator ti;
919 for (ti = local_vec.begin(); ti != local_vec.end(); ++ti)
920 pu.Update(**ti);
921 return t_ret;
922 }
923
924 /* +++++++++++++++ Deleting ++++++++++++++++ */
925
929 static void DeleteFace(MeshType &m, FaceType &f)
930 {
931 assert(&f >= &m.face.front() && &f <= &m.face.back());
932 assert(!f.IsD());
933 f.Dealloc();
934 f.SetD();
935 --m.fn;
936 }
937
941 static void DeleteVertex(MeshType &m, VertexType &v)
942 {
943 assert(&v >= &m.vert.front() && &v <= &m.vert.back());
944 assert(!v.IsD());
945 v.SetD();
946 --m.vn;
947 }
948
952 static void DeleteEdge(MeshType &m, EdgeType &e)
953 {
954 assert(&e >= &m.edge.front() && &e <= &m.edge.back());
955 assert(!e.IsD());
956 e.SetD();
957 --m.en;
958 }
959
963 static void DeleteHEdge(MeshType &m, HEdgeType &h)
964 {
965 assert(&h >= &m.hedge.front() && &h <= &m.hedge.back());
966 assert(!h.IsD());
967 h.SetD();
968 --m.hn;
969 }
970
974 static void DeleteTetra(MeshType &m, TetraType &t)
975 {
976 assert(&t >= &m.tetra.front() && &t <= &m.tetra.back());
977 assert(!t.IsD());
978 t.SetD();
979 --m.tn;
980 }
981
982 /*
983 Function to rearrange the vertex vector according to a given index permutation
984 the permutation is vector such that after calling this function
985
986 m.vert[ newVertIndex[i] ] = m.vert[i];
987
988 e.g. newVertIndex[i] is the new index of the vertex i
989
990 */
991 static void PermutateVertexVector(MeshType &m, PointerUpdater<VertexPointer> &pu)
992 {
993 if(m.vert.empty()) return;
994 for(size_t i=0;i<m.vert.size();++i)
995 {
996 if(pu.remap[i]<size_t(m.vn))
997 {
998 assert(!m.vert[i].IsD());
999 m.vert[ pu.remap [i] ].ImportData(m.vert[i]);
1000 if(HasVFAdjacency(m))
1001 {
1002 if (m.vert[i].IsVFInitialized())
1003 {
1004 m.vert[ pu.remap[i] ].VFp() = m.vert[i].cVFp();
1005 m.vert[ pu.remap[i] ].VFi() = m.vert[i].cVFi();
1006 }
1007 else m.vert [ pu.remap[i] ].VFClear();
1008 }
1009 if(HasVEAdjacency(m))
1010 {
1011 if (m.vert[i].IsVEInitialized())
1012 {
1013 m.vert[ pu.remap[i] ].VEp() = m.vert[i].cVEp();
1014 m.vert[ pu.remap[i] ].VEi() = m.vert[i].cVEi();
1015 }
1016 else m.vert [ pu.remap[i] ].VEClear();
1017 }
1018 if (HasVTAdjacency(m))
1019 {
1020 if (m.vert[i].IsVTInitialized())
1021 {
1022 m.vert[ pu.remap[i] ].VTp() = m.vert[i].cVTp();
1023 m.vert[ pu.remap[i] ].VTi() = m.vert[i].cVTi();
1024 }
1025 else m.vert[ pu.remap[i] ].VTClear();
1026 }
1027 }
1028 }
1029
1030 // reorder the optional atttributes in m.vert_attr to reflect the changes
1031 ReorderAttribute(m.vert_attr,pu.remap,m);
1032
1033 // setup the pointer updater
1034 pu.oldBase = &m.vert[0];
1035 pu.oldEnd = &m.vert.back()+1;
1036
1037 // resize
1038 m.vert.resize(m.vn);
1039
1040 // setup the pointer updater
1041 pu.newBase = (m.vert.empty())?0:&m.vert[0];
1042 pu.newEnd = (m.vert.empty())?0:&m.vert.back()+1;
1043
1044 // resize the optional atttributes in m.vert_attr to reflect the changes
1045 ResizeAttribute(m.vert_attr,m.vn,m);
1046
1047 // Loop on the face to update the pointers FV relation (vertex refs)
1048 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
1049 if(!(*fi).IsD())
1050 for(int i=0;i<fi->VN();++i)
1051 {
1052 size_t oldIndex = (*fi).V(i) - pu.oldBase;
1053 assert(pu.oldBase <= (*fi).V(i) && oldIndex < pu.remap.size());
1054 (*fi).V(i) = pu.newBase+pu.remap[oldIndex];
1055 }
1056 // Loop on the tetras to update the pointers TV relation (vertex refs)
1057 for(TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
1058 if(!(*ti).IsD())
1059 for(int i = 0; i < 4; ++i)
1060 {
1061 size_t oldIndex = (*ti).V(i) - pu.oldBase;
1062 assert(pu.oldBase <= (*ti).V(i) && oldIndex < pu.remap.size());
1063 (*ti).V(i) = pu.newBase+pu.remap[oldIndex];
1064 }
1065 // Loop on the edges to update the pointers EV relation (vertex refs)
1066 // if(HasEVAdjacency(m))
1067 for(EdgeIterator ei=m.edge.begin();ei!=m.edge.end();++ei)
1068 if(!(*ei).IsD())
1069 {
1070 pu.Update((*ei).V(0));
1071 pu.Update((*ei).V(1));
1072 }
1073 }
1074
1075 static void CompactEveryVector(MeshType &m)
1076 {
1077 CompactVertexVector(m);
1078 CompactEdgeVector(m);
1079 CompactFaceVector(m);
1080 CompactTetraVector(m);
1081 }
1082
1090 static void CompactVertexVector( MeshType &m, PointerUpdater<VertexPointer> &pu )
1091 {
1092 // If already compacted fast return please!
1093 if(m.vn==(int)m.vert.size()) return;
1094
1095 // newVertIndex [ <old_vert_position> ] gives you the new position of the vertex in the vector;
1096 pu.remap.resize( m.vert.size(),std::numeric_limits<size_t>::max() );
1097
1098 size_t pos=0;
1099 size_t i=0;
1100
1101 for(i=0;i<m.vert.size();++i)
1102 {
1103 if(!m.vert[i].IsD())
1104 {
1105 pu.remap[i]=pos;
1106 ++pos;
1107 }
1108 }
1109 assert((int)pos==m.vn);
1110
1111 PermutateVertexVector(m, pu);
1112 }
1113
1115 static void CompactVertexVector( MeshType &m ) {
1116 PointerUpdater<VertexPointer> pu;
1117 CompactVertexVector(m,pu);
1118 }
1119
1128 static void CompactEdgeVector( MeshType &m, PointerUpdater<EdgePointer> &pu )
1129 {
1130 // If already compacted fast return please!
1131 if(m.en==(int)m.edge.size()) return;
1132
1133 // remap [ <old_edge_position> ] gives you the new position of the edge in the vector;
1134 pu.remap.resize( m.edge.size(),std::numeric_limits<size_t>::max() );
1135
1136 size_t pos=0;
1137 size_t i=0;
1138
1139 for(i=0;i<m.edge.size();++i)
1140 {
1141 if(!m.edge[i].IsD())
1142 {
1143 pu.remap[i]=pos;
1144 ++pos;
1145 }
1146 }
1147 assert((int)pos==m.en);
1148
1149 // the actual copying of the data.
1150 for(size_t i=0;i<m.edge.size();++i)
1151 {
1152 if(pu.remap[i]<size_t(m.en)) // uninitialized entries in the remap vector has max_int value;
1153 {
1154 assert(!m.edge[i].IsD());
1155 m.edge[ pu.remap [i] ].ImportData(m.edge[i]);
1156 // copy the vertex reference (they are not data!)
1157 m.edge[ pu.remap[i] ].V(0) = m.edge[i].cV(0);
1158 m.edge[ pu.remap[i] ].V(1) = m.edge[i].cV(1);
1159 // Now just copy the adjacency pointers (without changing them, to be done later)
1160 if(HasVEAdjacency(m))
1161 //if (m.edge[i].cVEp(0)!=0)
1162 {
1163 m.edge[ pu.remap[i] ].VEp(0) = m.edge[i].cVEp(0);
1164 m.edge[ pu.remap[i] ].VEi(0) = m.edge[i].cVEi(0);
1165 m.edge[ pu.remap[i] ].VEp(1) = m.edge[i].cVEp(1);
1166 m.edge[ pu.remap[i] ].VEi(1) = m.edge[i].cVEi(1);
1167 }
1168 if(HasEEAdjacency(m))
1169// if (m.edge[i].cEEp(0)!=0)
1170 {
1171 m.edge[ pu.remap[i] ].EEp(0) = m.edge[i].cEEp(0);
1172 m.edge[ pu.remap[i] ].EEi(0) = m.edge[i].cEEi(0);
1173 m.edge[ pu.remap[i] ].EEp(1) = m.edge[i].cEEp(1);
1174 m.edge[ pu.remap[i] ].EEi(1) = m.edge[i].cEEi(1);
1175 }
1176 if(HasEFAdjacency(m))
1177// if (m.edge[i].cEEp(0)!=0)
1178 {
1179 m.edge[ pu.remap[i] ].EFp() = m.edge[i].cEFp();
1180 m.edge[ pu.remap[i] ].EFi() = m.edge[i].cEFi();
1181 m.edge[ pu.remap[i] ].EFp() = m.edge[i].cEFp();
1182 m.edge[ pu.remap[i] ].EFi() = m.edge[i].cEFi();
1183 }
1184
1185 }
1186 }
1187
1188 // reorder the optional attributes in m.vert_attr to reflect the changes
1189 ReorderAttribute(m.edge_attr, pu.remap,m);
1190
1191 // setup the pointer updater
1192 pu.oldBase = &m.edge[0];
1193 pu.oldEnd = &m.edge.back()+1;
1194
1195 // THE resize
1196 m.edge.resize(m.en);
1197
1198 // setup the pointer updater
1199 pu.newBase = (m.edge.empty())?0:&m.edge[0];
1200 pu.newEnd = (m.edge.empty())?0:&m.edge.back()+1;
1201
1202 // resize the optional atttributes in m.vert_attr to reflect the changes
1203 ResizeAttribute(m.edge_attr,m.en,m);
1204
1205 // Loop on the vertices to update the pointers of VE relation
1206 if(HasVEAdjacency(m))
1207 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
1208 if(!(*vi).IsD()) pu.Update((*vi).VEp());
1209
1210 // Loop on the edges to update the pointers EE VE relation
1211 for(EdgeIterator ei=m.edge.begin();ei!=m.edge.end();++ei)
1212 for(unsigned int i=0;i<2;++i)
1213 {
1214 if(HasVEAdjacency(m))
1215 pu.Update((*ei).VEp(i));
1216 if(HasEEAdjacency(m))
1217 pu.Update((*ei).EEp(i));
1218// if(HasEFAdjacency(m))
1219// pu.Update((*ei).EFp());
1220 }
1221 }
1222
1224 static void CompactEdgeVector( MeshType &m ) {
1225 PointerUpdater<EdgePointer> pu;
1226 CompactEdgeVector(m,pu);
1227 }
1228
1237 static void CompactFaceVector( MeshType &m, PointerUpdater<FacePointer> &pu )
1238 {
1239 // If already compacted fast return please!
1240 if(m.fn==(int)m.face.size()) return;
1241
1242 // newFaceIndex [ <old_face_position> ] gives you the new position of the face in the vector;
1243 pu.remap.resize( m.face.size(),std::numeric_limits<size_t>::max() );
1244
1245 size_t pos=0;
1246 for(size_t i=0;i<m.face.size();++i)
1247 {
1248 if(!m.face[i].IsD())
1249 {
1250 if(pos!=i)
1251 {
1252 m.face[pos].ImportData(m.face[i]);
1253 if(FaceType::HasPolyInfo())
1254 {
1255 m.face[pos].Dealloc();
1256 m.face[pos].Alloc(m.face[i].VN());
1257 }
1258 for(int j=0;j<m.face[i].VN();++j)
1259 m.face[pos].V(j) = m.face[i].V(j);
1260
1261 if(HasVFAdjacency(m))
1262 for(int j=0;j<m.face[i].VN();++j)
1263 {
1264 if (m.face[i].IsVFInitialized(j)) {
1265 m.face[pos].VFp(j) = m.face[i].cVFp(j);
1266 m.face[pos].VFi(j) = m.face[i].cVFi(j);
1267 }
1268 else m.face[pos].VFClear(j);
1269 }
1270 if(HasFFAdjacency(m))
1271 for(int j=0;j<m.face[i].VN();++j)
1272 {
1273 m.face[pos].FFp(j) = m.face[i].cFFp(j);
1274 m.face[pos].FFi(j) = m.face[i].cFFi(j);
1275 }
1276 }
1277 pu.remap[i]=pos;
1278 ++pos;
1279 }
1280 }
1281 assert((int)pos==m.fn);
1282
1283 // reorder the optional atttributes in m.face_attr to reflect the changes
1284 ReorderAttribute(m.face_attr,pu.remap,m);
1285
1286 FacePointer fbase=&m.face[0];
1287
1288 // Loop on the vertices to correct VF relation
1289 if(HasVFAdjacency(m))
1290 {
1291 for (VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
1292 if(!(*vi).IsD())
1293 {
1294 if ((*vi).IsVFInitialized() && (*vi).VFp()!=0 )
1295 {
1296 size_t oldIndex = (*vi).cVFp() - fbase;
1297 assert(fbase <= (*vi).cVFp() && oldIndex < pu.remap.size());
1298 (*vi).VFp() = fbase+pu.remap[oldIndex];
1299 }
1300 }
1301 }
1302
1303 // Loop on the faces to correct VF and FF relations
1304 pu.oldBase = &m.face[0];
1305 pu.oldEnd = &m.face.back()+1;
1306 for(size_t i=m.fn;i<m.face.size();++i)
1307 m.face[i].Dealloc();
1308 m.face.resize(m.fn);
1309 pu.newBase = (m.face.empty())?0:&m.face[0];
1310 pu.newEnd = (m.face.empty())?0:&m.face.back()+1;
1311
1312
1313 // resize the optional atttributes in m.face_attr to reflect the changes
1314 ResizeAttribute(m.face_attr,m.fn,m);
1315
1316 // now we update the various (not null) face pointers (inside VF and FF relations)
1317 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
1318 if(!(*fi).IsD())
1319 {
1320 if(HasVFAdjacency(m))
1321 for(int i=0;i<(*fi).VN();++i)
1322 if ((*fi).IsVFInitialized(i) && (*fi).VFp(i)!=0 )
1323 {
1324 size_t oldIndex = (*fi).VFp(i) - fbase;
1325 assert(fbase <= (*fi).VFp(i) && oldIndex < pu.remap.size());
1326 (*fi).VFp(i) = fbase+pu.remap[oldIndex];
1327 }
1328 if(HasFFAdjacency(m))
1329 for(int i=0;i<(*fi).VN();++i)
1330 if ((*fi).cFFp(i)!=0)
1331 {
1332 size_t oldIndex = (*fi).FFp(i) - fbase;
1333 assert(fbase <= (*fi).FFp(i) && oldIndex < pu.remap.size());
1334 (*fi).FFp(i) = fbase+pu.remap[oldIndex];
1335 }
1336 }
1337
1338
1339
1340 }
1341
1343 static void CompactFaceVector( MeshType &m ) {
1344 PointerUpdater<FacePointer> pu;
1345 CompactFaceVector(m,pu);
1346 }
1347
1356 static void CompactTetraVector(MeshType & m, PointerUpdater<TetraPointer> & pu)
1357 {
1358 //nothing to do
1359 if (size_t(m.tn) == m.tetra.size())
1360 return;
1361
1362 //init the remap
1363 pu.remap.resize(m.tetra.size(), std::numeric_limits<size_t>::max());
1364
1365 //cycle over all the tetras, pos is the last not D() position, I is the index
1366 //when pos != i and !tetra[i].IsD() => we need to compact and update adj
1367 size_t pos = 0;
1368 for (size_t i = 0; i < m.tetra.size(); ++i)
1369 {
1370 if (!m.tetra[i].IsD())
1371 {
1372 if (pos != i)
1373 {
1374 //import data
1375 m.tetra[pos].ImportData(m.tetra[i]);
1376 //import vertex refs
1377 for (int j = 0; j < 4; ++j)
1378 m.tetra[pos].V(j) = m.tetra[i].V(j);
1379 //import VT adj
1380 if (HasVTAdjacency(m))
1381 for (int j = 0; j < 4; ++j)
1382 {
1383 if (m.tetra[i].IsVTInitialized(j))
1384 {
1385 m.tetra[pos].VTp(j) = m.tetra[i].VTp(j);
1386 m.tetra[pos].VTi(j) = m.tetra[i].VTi(j);
1387 }
1388 else
1389 m.tetra[pos].VTClear(j);
1390 }
1391 //import TT adj
1392 if (HasTTAdjacency(m))
1393 for (int j = 0; j < 4; ++j)
1394 {
1395 m.tetra[pos].TTp(j) = m.tetra[i].cTTp(j);
1396 m.tetra[pos].TTi(j) = m.tetra[i].cTTi(j);
1397 }
1398 }
1399 //update remapping and advance pos
1400 pu.remap[i] = pos;
1401 ++pos;
1402 }
1403 }
1404
1405 assert(size_t(m.tn) == pos);
1406 //reorder the optional attributes in m.tetra_attr
1407 ReorderAttribute(m.tetra_attr, pu.remap, m);
1408 // resize the optional atttributes in m.tetra_attr to reflect the changes
1409 ResizeAttribute(m.tetra_attr, m.tn, m);
1410
1411 // Loop on the tetras to correct VT and TT relations
1412 pu.oldBase = &m.tetra[0];
1413 pu.oldEnd = &m.tetra.back() + 1;
1414
1415 m.tetra.resize(m.tn);
1416 pu.newBase = (m.tetra.empty()) ? 0 : &m.tetra[0];
1417 pu.newEnd = (m.tetra.empty()) ? 0 : &m.tetra.back() + 1;
1418
1419 TetraPointer tbase = &m.tetra[0];
1420
1421 //Loop on the vertices to correct VT relation (since we moved things around)
1422 if (HasVTAdjacency(m))
1423 {
1424 for (VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
1425 if (!(*vi).IsD())
1426 {
1427 if ((*vi).IsVTInitialized() && (*vi).VTp() != 0)
1428 {
1429 size_t oldIndex = (*vi).cVTp() - tbase;
1430 assert(tbase <= (*vi).cVTp() && oldIndex < pu.remap.size());
1431 (*vi).VTp() = tbase + pu.remap[oldIndex];
1432 }
1433 }
1434 }
1435
1436 // Loop on the tetras to correct the VT and TT relations
1437 for (TetraIterator ti = m.tetra.begin(); ti != m.tetra.end(); ++ti)
1438 if (!(*ti).IsD())
1439 {
1440 //VT
1441 if (HasVTAdjacency(m))
1442 for (int i = 0; i < 4; ++i)
1443 if ((*ti).IsVTInitialized(i) && (*ti).VTp(i) != 0)
1444 {
1445 size_t oldIndex = (*ti).VTp(i) - tbase;
1446 assert(tbase <= (*ti).VTp(i) && oldIndex < pu.remap.size());
1447 (*ti).VTp(i) = tbase + pu.remap[oldIndex];
1448 }
1449 //TT
1450 if (HasTTAdjacency(m))
1451 for (int i = 0; i < 4; ++i)
1452 if ((*ti).cTTp(i) != 0)
1453 {
1454 size_t oldIndex = (*ti).TTp(i) - tbase;
1455 assert(tbase <= (*ti).TTp(i) && oldIndex < pu.remap.size());
1456 (*ti).TTp(i) = tbase + pu.remap[oldIndex];
1457 }
1458 }
1459 }
1460
1462 static void CompactTetraVector(MeshType &m)
1463 {
1464 PointerUpdater<TetraPointer> pu;
1465 CompactTetraVector(m, pu);
1466 }
1467
1468
1469public:
1470
1474 template <class ATTR_TYPE>
1475 static
1476 bool IsValidHandle( const MeshType & m, const typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> & a){
1477 if(a._handle == nullptr) return false;
1478 for(AttrIterator i = m.vert_attr.begin(); i!=m.vert_attr.end();++i)
1479 if ( (*i).n_attr == a.n_attr ) return true;
1480 return false;
1481 }
1482
1486 template <class ATTR_TYPE>
1487 static
1488 bool IsValidHandle( const MeshType & m, const typename MeshType::template ConstPerVertexAttributeHandle<ATTR_TYPE> & a){
1489 if(a._handle == nullptr) return false;
1490 for(AttrIterator i = m.vert_attr.begin(); i!=m.vert_attr.end();++i)
1491 if ( (*i).n_attr == a.n_attr ) return true;
1492 return false;
1493 }
1494
1499 template <class ATTR_TYPE>
1500 static
1501 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1502 AddPerVertexAttribute( MeshType & m, std::string name){
1503 PAIte i;
1504 PointerToAttribute h;
1505 h._name = name;
1506 if(!name.empty()){
1507 i = m.vert_attr.find(h);
1508 assert(i ==m.vert_attr.end() );// an attribute with this name exists
1509 }
1510
1511 h._sizeof = sizeof(ATTR_TYPE);
1512 h._padding = 0;
1513 h._handle = new SimpleTempData<VertContainer,ATTR_TYPE>(m.vert);
1514 h._type = typeid(ATTR_TYPE);
1515 m.attrn++;
1516 h.n_attr = m.attrn;
1517 std::pair < AttrIterator , bool> res = m.vert_attr.insert(h);
1518 return typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr );
1519 }
1520
1521 template <class ATTR_TYPE>
1522 static typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1523 AddPerVertexAttribute( MeshType & m){
1524 return AddPerVertexAttribute<ATTR_TYPE>(m,std::string(""));
1525 }
1526
1531 template <class ATTR_TYPE>
1532 static
1533 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1534 GetPerVertexAttribute( MeshType & m, std::string name = std::string("")){
1535 typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> h;
1536 if(!name.empty()){
1537 h = FindPerVertexAttribute<ATTR_TYPE>(m,name);
1538 if(IsValidHandle(m,h))
1539 return h;
1540 }
1541 return AddPerVertexAttribute<ATTR_TYPE>(m,name);
1542 }
1543
1548 template <class ATTR_TYPE>
1549 static
1550 typename MeshType::template ConstPerVertexAttributeHandle<ATTR_TYPE>
1551 GetPerVertexAttribute( const MeshType & m, std::string name = std::string("")){
1552 return FindPerVertexAttribute<ATTR_TYPE>(m,name);
1553 }
1554
1558 template <class ATTR_TYPE>
1559 static typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>
1560 FindPerVertexAttribute( MeshType & m, const std::string & name)
1561 {
1562 assert(!name.empty());
1563 PointerToAttribute h1; h1._name = name;
1564 typename std::set<PointerToAttribute > :: iterator i;
1565
1566 i =m.vert_attr.find(h1);
1567 if(i!=m.vert_attr.end())
1568 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1569 if( (*i)._padding != 0 ){
1570 PointerToAttribute attr = (*i); // copy the PointerToAttribute
1571 m.vert_attr.erase(i); // remove it from the set
1572 FixPaddedPerVertexAttribute<ATTR_TYPE>(m,attr);
1573 std::pair<AttrIterator,bool> new_i = m.vert_attr.insert(attr); // insert the modified PointerToAttribute
1574 assert(new_i.second);
1575 i = new_i.first;
1576 }
1577 return typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1578 }
1579 return typename MeshType:: template PerVertexAttributeHandle<ATTR_TYPE>(nullptr,0);
1580 }
1581
1588 template <class ATTR_TYPE>
1589 static typename MeshType::template ConstPerVertexAttributeHandle<ATTR_TYPE>
1590 FindPerVertexAttribute( const MeshType & m, const std::string & name)
1591 {
1592 if(!name.empty()){
1593 PointerToAttribute h1; h1._name = name;
1594 typename std::set<PointerToAttribute > :: iterator i;
1595
1596 i =m.vert_attr.find(h1);
1597 if(i!=m.vert_attr.end()){
1598 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1599 return typename MeshType::template ConstPerVertexAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1600 }
1601 }
1602 }
1603 return typename MeshType:: template ConstPerVertexAttributeHandle<ATTR_TYPE>(nullptr,0);
1604 }
1605
1609 template <class ATTR_TYPE>
1610 static void GetAllPerVertexAttribute(const MeshType & m, std::vector<std::string> &all){
1611 all.clear();
1612 typename std::set<PointerToAttribute > ::const_iterator i;
1613 for(i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i )
1614 if(!(*i)._name.empty())
1615 {
1616 typename MeshType:: template ConstPerVertexAttributeHandle<ATTR_TYPE> hh;
1617 hh = Allocator<MeshType>:: template FindPerVertexAttribute <ATTR_TYPE>(m,(*i)._name);
1618 if(IsValidHandle<ATTR_TYPE>(m,hh))
1619 all.push_back((*i)._name);
1620 }
1621 }
1622
1623 template <class ATTR_TYPE>
1624 static
1625 void
1626 ClearPerVertexAttribute( MeshType & m,typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> & h, const ATTR_TYPE & initVal = ATTR_TYPE()){
1627 typename std::set<PointerToAttribute > ::iterator i;
1628 for( i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i)
1629 if( (*i)._handle == h._handle ){
1630 for(typename MeshType::VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
1631 h[vi] = initVal;
1632 return;}
1633 assert(0);
1634 }
1635
1638 template <class ATTR_TYPE>
1639 static
1640 void
1641 DeletePerVertexAttribute( MeshType & m,typename MeshType::template PerVertexAttributeHandle<ATTR_TYPE> & h){
1642 typename std::set<PointerToAttribute > ::iterator i;
1643 for( i = m.vert_attr.begin(); i != m.vert_attr.end(); ++i)
1644 if( (*i)._handle == h._handle ){
1645 delete ((SimpleTempData<VertContainer,ATTR_TYPE>*)(*i)._handle);
1646 m.vert_attr.erase(i);
1647 return;}
1648 }
1649
1650 // Generic DeleteAttribute.
1651 // It must not crash if you try to delete a non existing attribute,
1652 // because you do not have a way of asking for a handle of an attribute for which you do not know the type.
1653 static
1654 bool DeletePerVertexAttribute( MeshType & m, std::string name){
1655 AttrIterator i;
1656 PointerToAttribute h1; h1._name = name;
1657 i = m.vert_attr.find(h1);
1658 if(i==m.vert_attr.end()) return false;
1659 delete ((SimpleTempDataBase*)(*i)._handle);
1660 m.vert_attr.erase(i);
1661 return true;
1662 }
1663
1664
1665
1667 template <class ATTR_TYPE>
1668 static
1669 bool IsValidHandle( const MeshType & m, const typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE> & a){
1670 if(a._handle == nullptr) return false;
1671 for(AttrIterator i = m.edge_attr.begin(); i!=m.edge_attr.end();++i)
1672 if ( (*i).n_attr == a.n_attr ) return true;
1673 return false;
1674 }
1675
1676 template <class ATTR_TYPE>
1677 static
1678 bool IsValidHandle( const MeshType & m, const typename MeshType::template ConstPerEdgeAttributeHandle<ATTR_TYPE> & a){
1679 if(a._handle == nullptr) return false;
1680 for(AttrIterator i = m.edge_attr.begin(); i!=m.edge_attr.end();++i)
1681 if ( (*i).n_attr == a.n_attr ) return true;
1682 return false;
1683 }
1684
1685 template <class ATTR_TYPE>
1686 static
1687 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1688 AddPerEdgeAttribute( MeshType & m, std::string name){
1689 PAIte i;
1690 PointerToAttribute h;
1691 h._name = name;
1692 if(!name.empty()){
1693 i = m.edge_attr.find(h);
1694 assert(i ==m.edge_attr.end() );// an attribute with this name exists
1695 }
1696 h._sizeof = sizeof(ATTR_TYPE);
1697 h._padding = 0;
1698 // h._typename = typeid(ATTR_TYPE).name();
1699 h._handle = new SimpleTempData<EdgeContainer,ATTR_TYPE>(m.edge);
1700 h._type = typeid(ATTR_TYPE);
1701 m.attrn++;
1702 h.n_attr = m.attrn;
1703 std::pair < AttrIterator , bool> res = m.edge_attr.insert(h);
1704 return typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
1705 }
1706
1707 template <class ATTR_TYPE>
1708 static
1709 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1710 AddPerEdgeAttribute( MeshType & m){
1711 return AddPerEdgeAttribute<ATTR_TYPE>(m,std::string(""));
1712 }
1713
1718 template <class ATTR_TYPE>
1719 static
1720 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1721 GetPerEdgeAttribute( MeshType & m, std::string name = std::string("")){
1722 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE> h;
1723 if(!name.empty()){
1724 h = FindPerEdgeAttribute<ATTR_TYPE>(m,name);
1725 if(IsValidHandle(m,h))
1726 return h;
1727 }
1728 return AddPerEdgeAttribute<ATTR_TYPE>(m,name);
1729 }
1730
1731 template <class ATTR_TYPE>
1732 static
1733 typename MeshType::template ConstPerEdgeAttributeHandle<ATTR_TYPE>
1734 GetPerEdgeAttribute( const MeshType & m, std::string name = std::string("")){
1735 return FindPerEdgeAttribute<ATTR_TYPE>(m,name);
1736 }
1737
1738 template <class ATTR_TYPE>
1739 static
1740 typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>
1741 FindPerEdgeAttribute( MeshType & m, const std::string & name){
1742 assert(!name.empty());
1743 PointerToAttribute h1; h1._name = name;
1744 typename std::set<PointerToAttribute > ::const_iterator i;
1745
1746 i =m.edge_attr.find(h1);
1747 if(i!=m.edge_attr.end())
1748 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1749 if( (*i)._padding != 0 ){
1750 PointerToAttribute attr = (*i); // copy the PointerToAttribute
1751 m.edge_attr.erase(i); // remove it from the set
1752 FixPaddedPerEdgeAttribute<ATTR_TYPE>(m,attr);
1753 std::pair<AttrIterator,bool> new_i = m.edge_attr.insert(attr); // insert the modified PointerToAttribute
1754 assert(new_i.second);
1755 i = new_i.first;
1756 }
1757 return typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1758 }
1759
1760 return typename MeshType:: template PerEdgeAttributeHandle<ATTR_TYPE>(nullptr,0);
1761 }
1762
1763 template <class ATTR_TYPE>
1764 static
1765 typename MeshType::template ConstPerEdgeAttributeHandle<ATTR_TYPE>
1766 FindPerEdgeAttribute( const MeshType & m, const std::string & name){
1767 if(!name.empty()){
1768 PointerToAttribute h1; h1._name = name;
1769 typename std::set<PointerToAttribute > ::const_iterator i;
1770
1771 i =m.edge_attr.find(h1);
1772 if(i!=m.edge_attr.end()){
1773 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1774 return typename MeshType::template ConstPerEdgeAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1775 }
1776 }
1777 }
1778 return typename MeshType:: template ConstPerEdgeAttributeHandle<ATTR_TYPE>(nullptr,0);
1779 }
1780
1781 template <class ATTR_TYPE>
1782 static void GetAllPerEdgeAttribute(const MeshType & m, std::vector<std::string> &all){
1783 all.clear();
1784 typename std::set<PointerToAttribute > :: const_iterator i;
1785 for(i = m.edge_attr.begin(); i != m.edge_attr.end(); ++i )
1786 if(!(*i)._name.empty())
1787 {
1788 typename MeshType:: template ConstPerEdgeAttributeHandle<ATTR_TYPE> hh;
1789 hh = Allocator<MeshType>:: template FindPerEdgeAttribute <ATTR_TYPE>(m,(*i)._name);
1790 if(IsValidHandle<ATTR_TYPE>(m,hh))
1791 all.push_back((*i)._name);
1792 }
1793 }
1794
1797 template <class ATTR_TYPE>
1798 static
1799 void
1800 DeletePerEdgeAttribute( MeshType & m,typename MeshType::template PerEdgeAttributeHandle<ATTR_TYPE> & h){
1801 typename std::set<PointerToAttribute > ::iterator i;
1802 for( i = m.edge_attr.begin(); i != m.edge_attr.end(); ++i)
1803 if( (*i)._handle == h._handle ){
1804 delete ((SimpleTempData<EdgeContainer,ATTR_TYPE>*)(*i)._handle);
1805 m.edge_attr.erase(i);
1806 return;}
1807 }
1808
1809 // Generic DeleteAttribute.
1810 // It must not crash if you try to delete a non existing attribute,
1811 // because you do not have a way of asking for a handle of an attribute for which you do not know the type.
1812 static
1813 bool DeletePerEdgeAttribute( MeshType & m, std::string name){
1814 AttrIterator i;
1815 PointerToAttribute h1; h1._name = name;
1816 i = m.edge_attr.find(h1);
1817 if(i==m.edge_attr.end()) return false;
1818 delete ((SimpleTempDataBase*)(*i)._handle);
1819 m.edge_attr.erase(i);
1820 return true;
1821 }
1822
1824
1827 template <class ATTR_TYPE>
1828 static
1829 bool IsValidHandle( const MeshType & m, const typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE> & a){
1830 if(a._handle == nullptr) return false;
1831 for(AttrIterator i = m.face_attr.begin(); i!=m.face_attr.end();++i)
1832 if ( (*i).n_attr == a.n_attr ) return true;
1833 return false;
1834 }
1835
1839 template <class ATTR_TYPE>
1840 static
1841 bool IsValidHandle( const MeshType & m, const typename MeshType::template ConstPerFaceAttributeHandle<ATTR_TYPE> & a){
1842 if(a._handle == nullptr) return false;
1843 for(AttrIterator i = m.face_attr.begin(); i!=m.face_attr.end();++i)
1844 if ( (*i).n_attr == a.n_attr ) return true;
1845 return false;
1846 }
1847
1848 template <class ATTR_TYPE>
1849 static
1850 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1851 AddPerFaceAttribute( MeshType & m, std::string name){
1852 PAIte i;
1853 PointerToAttribute h;
1854 h._name = name;
1855 if(!name.empty()){
1856 i = m.face_attr.find(h);
1857 assert(i ==m.face_attr.end() );// an attribute with this name exists
1858 }
1859
1860 h._sizeof = sizeof(ATTR_TYPE);
1861 h._padding = 0;
1862 h._handle = new SimpleTempData<FaceContainer,ATTR_TYPE>(m.face);
1863 h._type = typeid(ATTR_TYPE);
1864 m.attrn++;
1865 h.n_attr = m.attrn;
1866 std::pair < AttrIterator , bool> res = m.face_attr.insert(h);
1867 return typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
1868 }
1869
1870 template <class ATTR_TYPE>
1871 static
1872 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1873 AddPerFaceAttribute( MeshType & m){
1874 return AddPerFaceAttribute<ATTR_TYPE>(m,std::string(""));
1875 }
1876
1881 template <class ATTR_TYPE>
1882 static
1883 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1884 GetPerFaceAttribute( MeshType & m, std::string name = std::string("")){
1885 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE> h;
1886 if(!name.empty()){
1887 h = FindPerFaceAttribute<ATTR_TYPE>(m,name);
1888 if(IsValidHandle(m,h))
1889 return h;
1890 }
1891 return AddPerFaceAttribute<ATTR_TYPE>(m,name);
1892 }
1893
1898 template <class ATTR_TYPE>
1899 static
1900 typename MeshType::template ConstPerFaceAttributeHandle<ATTR_TYPE>
1901 GetPerFaceAttribute( const MeshType & m, std::string name = std::string("")){
1902 return FindPerFaceAttribute<ATTR_TYPE>(m,name);
1903 }
1904
1905 template <class ATTR_TYPE>
1906 static
1907 typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>
1908 FindPerFaceAttribute( MeshType & m, const std::string & name){
1909 assert(!name.empty());
1910 PointerToAttribute h1; h1._name = name;
1911 typename std::set<PointerToAttribute > ::iterator i;
1912
1913 i =m.face_attr.find(h1);
1914 if(i!=m.face_attr.end())
1915 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1916 if( (*i)._padding != 0 ){
1917 PointerToAttribute attr = (*i); // copy the PointerToAttribute
1918 m.face_attr.erase(i); // remove it from the set
1919 FixPaddedPerFaceAttribute<ATTR_TYPE>(m,attr);
1920 std::pair<AttrIterator,bool> new_i = m.face_attr.insert(attr); // insert the modified PointerToAttribute
1921 assert(new_i.second);
1922 i = new_i.first;
1923 }
1924 return typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1925 }
1926 return typename MeshType:: template PerFaceAttributeHandle<ATTR_TYPE>(nullptr,0);
1927 }
1928
1935 template <class ATTR_TYPE>
1936 static
1937 typename MeshType::template ConstPerFaceAttributeHandle<ATTR_TYPE>
1938 FindPerFaceAttribute( const MeshType & m, const std::string & name){
1939 if(!name.empty()){
1940 PointerToAttribute h1; h1._name = name;
1941 typename std::set<PointerToAttribute > ::iterator i;
1942
1943 i =m.face_attr.find(h1);
1944 if(i!=m.face_attr.end()){
1945 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
1946 return typename MeshType::template ConstPerFaceAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
1947 }
1948 }
1949 }
1950 return typename MeshType:: template ConstPerFaceAttributeHandle<ATTR_TYPE>(nullptr,0);
1951 }
1952
1953 template <class ATTR_TYPE>
1954 static void GetAllPerFaceAttribute(const MeshType & m, std::vector<std::string> &all){
1955 all.clear();
1956 typename std::set<PointerToAttribute > :: const_iterator i;
1957 for(i = m.face_attr.begin(); i != m.face_attr.end(); ++i )
1958 if(!(*i)._name.empty())
1959 {
1960 typename MeshType:: template ConstPerFaceAttributeHandle<ATTR_TYPE> hh;
1961 hh = Allocator<MeshType>:: template FindPerFaceAttribute <ATTR_TYPE>(m,(*i)._name);
1962 if(IsValidHandle<ATTR_TYPE>(m,hh))
1963 all.push_back((*i)._name);
1964 }
1965 }
1966
1969 template <class ATTR_TYPE>
1970 static void DeletePerFaceAttribute( MeshType & m,typename MeshType::template PerFaceAttributeHandle<ATTR_TYPE> & h){
1971 typename std::set<PointerToAttribute > ::iterator i;
1972 for( i = m.face_attr.begin(); i != m.face_attr.end(); ++i)
1973 if( (*i)._handle == h._handle ){
1974 delete ((SimpleTempData<FaceContainer,ATTR_TYPE>*)(*i)._handle);
1975 m.face_attr.erase(i);
1976 return;}
1977
1978 }
1979
1980 // Generic DeleteAttribute.
1981 // It must not crash if you try to delete a non existing attribute,
1982 // because you do not have a way of asking for a handle of an attribute for which you do not know the type.
1983 static bool DeletePerFaceAttribute( MeshType & m, std::string name){
1984 AttrIterator i;
1985 PointerToAttribute h1; h1._name = name;
1986 i = m.face_attr.find(h1);
1987 if(i==m.face_attr.end()) return false;
1988 delete ((SimpleTempDataBase*)(*i)._handle);
1989 m.face_attr.erase(i);
1990 return true;
1991 }
1992
1994 template <class ATTR_TYPE>
1995 static bool IsValidHandle(const MeshType & m, const typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> & a)
1996 {
1997 if (a._handle == nullptr)
1998 return false;
1999 for (AttrIterator i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
2000 if ((*i).n_attr == a.n_attr)
2001 return true;
2002 return false;
2003 }
2004
2005 template <class ATTR_TYPE>
2006 static bool IsValidHandle(const MeshType & m, const typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE> & a)
2007 {
2008 if (a._handle == nullptr)
2009 return false;
2010 for (AttrIterator i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
2011 if ((*i).n_attr == a.n_attr)
2012 return true;
2013 return false;
2014 }
2015
2016 template <class ATTR_TYPE>
2017 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> AddPerTetraAttribute(MeshType & m, std::string name)
2018 {
2019 PAIte i;
2020 PointerToAttribute h;
2021 h._name = name;
2022 if (!name.empty())
2023 {
2024 i = m.tetra_attr.find(h);
2025 assert(i == m.tetra_attr.end());
2026 }
2027
2028 h._sizeof = sizeof(ATTR_TYPE);
2029 h._padding = 0;
2030 h._handle = new SimpleTempData<TetraContainer, ATTR_TYPE>(m.tetra);
2031 h._type = typeid(ATTR_TYPE);
2032 m.attrn++;
2033 h.n_attr = m.attrn;
2034 std::pair<AttrIterator, bool> res = m.tetra_attr.insert(h);
2035 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>(res.first->_handle, res.first->n_attr);
2036 }
2037
2038 template <class ATTR_TYPE>
2039 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> AddPerTetraAttribute(MeshType &m)
2040 {
2041 return AddPerTetraAttribute<ATTR_TYPE>(m, std::string(""));
2042 }
2043
2048 template <class ATTR_TYPE>
2049 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> GetPerTetraAttribute(MeshType &m, std::string name = std::string(""))
2050 {
2051 typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> h;
2052 if (!name.empty())
2053 {
2054 h = FindPerTetraAttribute<ATTR_TYPE>(m, name);
2055 if (IsValidHandle(m, h))
2056 return h;
2057 }
2058 return AddPerTetraAttribute<ATTR_TYPE>(m, name);
2059 }
2060
2061 template <class ATTR_TYPE>
2062 static typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE> GetPerTetraAttribute(const MeshType &m, std::string name = std::string(""))
2063 {
2064 return FindPerTetraAttribute<ATTR_TYPE>(m, name);
2065 }
2066
2067 template <class ATTR_TYPE>
2068 static typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> FindPerTetraAttribute(MeshType &m, const std::string &name)
2069 {
2070 assert(!name.empty());
2071 PointerToAttribute h1;
2072 h1._name = name;
2073 typename std::set<PointerToAttribute>::iterator i;
2074
2075 i = m.tetra_attr.find(h1);
2076 if (i != m.tetra_attr.end())
2077 if ((*i)._sizeof == sizeof(ATTR_TYPE))
2078 {
2079 if ((*i)._padding != 0)
2080 {
2081 PointerToAttribute attr = (*i); // copy the PointerToAttribute
2082 m.tetra_attr.erase(i); // remove it from the set
2083 FixPaddedPerTetraAttribute<ATTR_TYPE>(m, attr);
2084 std::pair<AttrIterator, bool> new_i = m.tetra_attr.insert(attr); // insert the modified PointerToAttribute
2085 assert(new_i.second);
2086 i = new_i.first;
2087 }
2088 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>((*i)._handle, (*i).n_attr);
2089 }
2090 return typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE>(nullptr, 0);
2091 }
2092
2093 template <class ATTR_TYPE>
2094 static typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE> FindPerTetraAttribute(const MeshType &m, const std::string &name)
2095 {
2096 if(!name.empty()){
2097 PointerToAttribute h1;
2098 h1._name = name;
2099 typename std::set<PointerToAttribute>::iterator i;
2100
2101 i = m.tetra_attr.find(h1);
2102 if (i != m.tetra_attr.end()){
2103 if ((*i)._sizeof == sizeof(ATTR_TYPE))
2104 {
2105 return typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE>((*i)._handle, (*i).n_attr);
2106 }
2107 }
2108 }
2109 return typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE>(nullptr, 0);
2110 }
2111
2112 template <class ATTR_TYPE>
2113 static void GetAllPerTetraAttribute(const MeshType &m, std::vector<std::string> &all)
2114 {
2115 all.clear();
2116 typename std::set<PointerToAttribute>::const_iterator i;
2117 for (i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
2118 if (!(*i)._name.empty())
2119 {
2120 typename MeshType::template ConstPerTetraAttributeHandle<ATTR_TYPE> hh;
2121 hh = Allocator<MeshType>::template FindPerTetraAttribute<ATTR_TYPE>(m, (*i)._name);
2122 if (IsValidHandle<ATTR_TYPE>(m, hh))
2123 all.push_back((*i)._name);
2124 }
2125 }
2126
2129 template <class ATTR_TYPE>
2130 static void DeletePerTetraAttribute(MeshType &m, typename MeshType::template PerTetraAttributeHandle<ATTR_TYPE> &h)
2131 {
2132 typename std::set<PointerToAttribute>::iterator i;
2133 for (i = m.tetra_attr.begin(); i != m.tetra_attr.end(); ++i)
2134 if ((*i)._handle == h._handle)
2135 {
2136 delete ((SimpleTempData<TetraContainer, ATTR_TYPE> *)(*i)._handle);
2137 m.tetra_attr.erase(i);
2138 return;
2139 }
2140 }
2141
2142 // Generic DeleteAttribute.
2143 // It must not crash if you try to delete a non existing attribute,
2144 // because you do not have a way of asking for a handle of an attribute for which you do not know the type.
2145 static bool DeletePerTetraAttribute(MeshType &m, std::string name)
2146 {
2147 AttrIterator i;
2148 PointerToAttribute h1;
2149 h1._name = name;
2150 i = m.tetra_attr.find(h1);
2151 if (i == m.tetra_attr.end())
2152 return false;
2153 delete ((SimpleTempDataBase *)(*i)._handle);
2154 m.tetra_attr.erase(i);
2155 return true;
2156 }
2157
2158
2160 template <class ATTR_TYPE>
2161 static
2162 bool IsValidHandle(const MeshType & m, const typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE> & a){
2163 if(a._handle == nullptr) return false;
2164 for(AttrIterator i = m.mesh_attr.begin(); i!=m.mesh_attr.end();++i)
2165 if ( (*i).n_attr == a.n_attr ) return true;
2166 return false;
2167 }
2168
2169 template <class ATTR_TYPE>
2170 static
2171 bool IsValidHandle(const MeshType & m, const typename MeshType::template ConstPerMeshAttributeHandle<ATTR_TYPE> & a){
2172 if(a._handle == nullptr) return false;
2173 for(AttrIterator i = m.mesh_attr.begin(); i!=m.mesh_attr.end();++i)
2174 if ( (*i).n_attr == a.n_attr ) return true;
2175 return false;
2176 }
2177
2178 template <class ATTR_TYPE>
2179 static
2180 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
2181 AddPerMeshAttribute( MeshType & m, std::string name){
2182 PAIte i;
2183 PointerToAttribute h;
2184 h._name = name;
2185 if(!name.empty()){
2186 i = m.mesh_attr.find(h);
2187 assert(i ==m.mesh_attr.end() );// an attribute with this name exists
2188 }
2189 h._sizeof = sizeof(ATTR_TYPE);
2190 h._padding = 0;
2191 h._handle = new Attribute<ATTR_TYPE>();
2192 h._type = typeid(ATTR_TYPE);
2193 m.attrn++;
2194 h.n_attr = m.attrn;
2195 std::pair < AttrIterator , bool> res = m.mesh_attr.insert(h);
2196 return typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>(res.first->_handle,res.first->n_attr);
2197 }
2198
2203 template <class ATTR_TYPE>
2204 static
2205 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
2206 GetPerMeshAttribute( MeshType & m, std::string name = std::string("")){
2207 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE> h;
2208 if(!name.empty()){
2209 h = FindPerMeshAttribute<ATTR_TYPE>(m,name);
2210 if(IsValidHandle(m,h))
2211 return h;
2212 }
2213 return AddPerMeshAttribute<ATTR_TYPE>(m,name);
2214 }
2215
2216 template <class ATTR_TYPE>
2217 static
2218 typename MeshType::template ConstPerMeshAttributeHandle<ATTR_TYPE>
2219 GetPerMeshAttribute(const MeshType & m, std::string name = std::string("")){
2220 return FindPerMeshAttribute<ATTR_TYPE>(m,name);
2221 }
2222
2223 template <class ATTR_TYPE>
2224 static
2225 typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>
2226 FindPerMeshAttribute( MeshType & m, const std::string & name){
2227 assert(!name.empty());
2228 PointerToAttribute h1; h1._name = name;
2229 typename std::set<PointerToAttribute > ::iterator i;
2230
2231 i =m.mesh_attr.find(h1);
2232 if(i!=m.mesh_attr.end())
2233 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
2234 if( (*i)._padding != 0 ){
2235 PointerToAttribute attr = (*i); // copy the PointerToAttribute
2236 m.mesh_attr.erase(i); // remove it from the set
2237 FixPaddedPerMeshAttribute<ATTR_TYPE>(m,attr);
2238 std::pair<AttrIterator,bool> new_i = m.mesh_attr.insert(attr); // insert the modified PointerToAttribute
2239 assert(new_i.second);
2240 i = new_i.first;
2241 }
2242
2243 return typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
2244 }
2245
2246 return typename MeshType:: template PerMeshAttributeHandle<ATTR_TYPE>(nullptr,0);
2247 }
2248
2249 template <class ATTR_TYPE>
2250 static
2251 typename MeshType::template ConstPerMeshAttributeHandle<ATTR_TYPE>
2252 FindPerMeshAttribute( const MeshType & m, const std::string & name){
2253 if (!name.empty()){
2254 PointerToAttribute h1; h1._name = name;
2255 typename std::set<PointerToAttribute > ::iterator i;
2256 i =m.mesh_attr.find(h1);
2257 if(i!=m.mesh_attr.end()){
2258 if((*i)._sizeof == sizeof(ATTR_TYPE) ){
2259 return typename MeshType::template ConstPerMeshAttributeHandle<ATTR_TYPE>((*i)._handle,(*i).n_attr);
2260 }
2261 }
2262 }
2263
2264 return typename MeshType:: template ConstPerMeshAttributeHandle<ATTR_TYPE>(nullptr,0);
2265 }
2266
2267 template <class ATTR_TYPE>
2268 static void GetAllPerMeshAttribute(const MeshType & m, std::vector<std::string> &all){
2269 typename std::set<PointerToAttribute > :: iterator i;
2270 for(i = m.mesh_attr.begin(); i != m.mesh_attr.end(); ++i )
2271 if((*i)._sizeof == sizeof(ATTR_TYPE))
2272 all.push_back((*i)._name);
2273 }
2274
2277 template <class ATTR_TYPE>
2278 static void DeletePerMeshAttribute( MeshType & m,typename MeshType::template PerMeshAttributeHandle<ATTR_TYPE> & h){
2279 typename std::set<PointerToAttribute > ::iterator i;
2280 for( i = m.mesh_attr.begin(); i != m.mesh_attr.end(); ++i)
2281 if( (*i)._handle == h._handle ){
2282 delete (( Attribute<ATTR_TYPE> *)(*i)._handle);
2283 m.mesh_attr.erase(i);
2284 return;}
2285 }
2286
2287 // Generic DeleteAttribute.
2288 // It must not crash if you try to delete a non existing attribute,
2289 // because you do not have a way of asking for a handle of an attribute for which you do not know the type.
2290 static bool DeletePerMeshAttribute( MeshType & m, std::string name){
2291 AttrIterator i;
2292 PointerToAttribute h1; h1._name = name;
2293 i = m.mesh_attr.find(h1);
2294 if (i==m.mesh_attr.end())
2295 return false;
2296 delete ((SimpleTempDataBase *)(*i)._handle);
2297 m.mesh_attr.erase(i);
2298 return true;
2299 }
2300
2301 template <class ATTR_TYPE>
2302 static void FixPaddedPerVertexAttribute (MeshType & m, PointerToAttribute & pa){
2303
2304 // create the container of the right type
2305 SimpleTempData<VertContainer,ATTR_TYPE>* _handle = new SimpleTempData<VertContainer,ATTR_TYPE>(m.vert);
2306
2307 // copy the padded container in the new one
2308 _handle->Resize(m.vert.size());
2309 for(size_t i = 0; i < m.vert.size(); ++i){
2310 ATTR_TYPE * dest = &(*_handle)[i];
2311 char * ptr = (char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2312 ATTR_TYPE* attrptr = (ATTR_TYPE*)ptr;
2313 *dest = attrptr[i * pa._sizeof ];
2314 //memcpy((void*)dest ,
2315 //(void*) &(ptr[i * pa._sizeof ]) ,sizeof(ATTR_TYPE));
2316 }
2317
2318 // remove the padded container
2319 delete ((SimpleTempDataBase*) pa._handle);
2320
2321 // update the pointer to data
2322 pa._sizeof = sizeof(ATTR_TYPE);
2323
2324 // update the pointer to data
2325 pa._handle = _handle;
2326
2327 // zero the padding
2328 pa._padding = 0;
2329 }
2330 template <class ATTR_TYPE>
2331 static void FixPaddedPerEdgeAttribute (MeshType & m, PointerToAttribute & pa){
2332
2333 // create the container of the right type
2334 SimpleTempData<EdgeContainer,ATTR_TYPE>* _handle = new SimpleTempData<EdgeContainer,ATTR_TYPE>(m.edge);
2335
2336 // copy the padded container in the new one
2337 _handle->Resize(m.edge.size());
2338 for(size_t i = 0; i < m.edge.size(); ++i){
2339 ATTR_TYPE * dest = &(*_handle)[i];
2340 char * ptr = (char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2341 ATTR_TYPE* attrptr = (ATTR_TYPE*)ptr;
2342 *dest = attrptr[i * pa._sizeof ];
2343 //memcpy((void*)dest ,
2344 //(void*) &(ptr[i * pa._sizeof ]) ,sizeof(ATTR_TYPE));
2345 }
2346
2347 // remove the padded container
2348 delete ((SimpleTempDataBase*) pa._handle);
2349
2350 // update the pointer to data
2351 pa._sizeof = sizeof(ATTR_TYPE);
2352
2353 // update the pointer to data
2354 pa._handle = _handle;
2355
2356 // zero the padding
2357 pa._padding = 0;
2358 }
2359
2360 template <class ATTR_TYPE>
2361 static void FixPaddedPerFaceAttribute ( MeshType & m,PointerToAttribute & pa){
2362
2363 // create the container of the right type
2364 SimpleTempData<FaceContainer,ATTR_TYPE>* _handle = new SimpleTempData<FaceContainer,ATTR_TYPE>(m.face);
2365
2366 // copy the padded container in the new one
2367 _handle->Resize(m.face.size());
2368 for(size_t i = 0; i < m.face.size(); ++i){
2369 ATTR_TYPE * dest = &(*_handle)[i];
2370 char * ptr = (char*)( ((SimpleTempDataBase *)pa._handle)->DataBegin());
2371 ATTR_TYPE* attrptr = (ATTR_TYPE*)ptr;
2372 *dest = attrptr[i * pa._sizeof ];
2373 //memcpy((void*)dest ,
2374 // (void*) &(ptr[i * pa._sizeof ]) ,sizeof(ATTR_TYPE));
2375 }
2376
2377 // remove the padded container
2378 delete ((SimpleTempDataBase*) pa._handle);
2379
2380 // update the pointer to data
2381 pa._sizeof = sizeof(ATTR_TYPE);
2382
2383 // update the pointer to data
2384 pa._handle = _handle;
2385
2386 // zero the padding
2387 pa._padding = 0;
2388 }
2389
2390 template <class ATTR_TYPE>
2391 static void FixPaddedPerTetraAttribute(MeshType &m, PointerToAttribute &pa)
2392 {
2393
2394 // create the container of the right type
2395 SimpleTempData<TetraContainer, ATTR_TYPE> *_handle = new SimpleTempData<TetraContainer, ATTR_TYPE>(m.tetra);
2396
2397 // copy the padded container in the new one
2398 _handle->Resize(m.tetra.size());
2399 for (size_t i = 0; i < m.tetra.size(); ++i)
2400 {
2401 ATTR_TYPE *dest = &(*_handle)[i];
2402 char *ptr = (char *)(((SimpleTempDataBase *)pa._handle)->DataBegin());
2403 ATTR_TYPE* attrptr = (ATTR_TYPE*)ptr;
2404 *dest = attrptr[i * pa._sizeof ];
2405 //memcpy((void *)dest,
2406 //(void *)&(ptr[i * pa._sizeof]), sizeof(ATTR_TYPE));
2407 }
2408
2409 // remove the padded container
2410 delete ((SimpleTempDataBase *)pa._handle);
2411
2412 // update the pointer to data
2413 pa._sizeof = sizeof(ATTR_TYPE);
2414
2415 // update the pointer to data
2416 pa._handle = _handle;
2417
2418 // zero the padding
2419 pa._padding = 0;
2420 }
2421
2422 template <class ATTR_TYPE>
2423 static void FixPaddedPerMeshAttribute ( MeshType & /* m */,PointerToAttribute & pa){
2424
2425 // create the container of the right type
2426 Attribute<ATTR_TYPE> * _handle = new Attribute<ATTR_TYPE>();
2427
2428 // copy the padded container in the new one
2429 ATTR_TYPE* dest = (ATTR_TYPE*)_handle->DataBegin();
2430 char* ptr = (char*)( ((Attribute<ATTR_TYPE> *)pa._handle)->DataBegin());
2431 ATTR_TYPE* attrptr = (ATTR_TYPE*)ptr;
2432 *dest = *attrptr;
2433 //memcpy((void*)dest ,(void*) &(ptr[0]) ,sizeof(ATTR_TYPE));
2434
2435 // remove the padded container
2436 delete ( (Attribute<ATTR_TYPE> *) pa._handle);
2437
2438 // update the pointer to data
2439 pa._sizeof = sizeof(ATTR_TYPE);
2440
2441 // update the pointer to data
2442 pa._handle = _handle;
2443
2444 // zero the padding
2445 pa._padding = 0;
2446 }
2447
2448}; // end Allocator class
2449
2450 // end doxygen group trimesh
2452} // end namespace tri
2453} // end namespace vcg
2454
2455#endif
vcg::Color4
Definition: color4.h:41
vcg::tri::Allocator::PointerUpdater
Accessory class to update pointers after eventual reallocation caused by adding elements.
Definition: allocate.h:145
vcg::tri::Allocator::PointerUpdater::Update
void Update(SimplexPointerType &vp)
Update a pointer to an element of a mesh after a reallocation.
Definition: allocate.h:153
vcg::tri::Allocator::PointerUpdater::NeedUpdate
bool NeedUpdate()
return true if the allocation operation that initialized this PointerUpdater has caused a reallocatio...
Definition: allocate.h:172
vcg::tri::Allocator
Class to safely add and delete elements in a mesh.
Definition: allocate.h:97
vcg::tri::Allocator::GetPerTetraAttribute
static MeshType::template PerTetraAttributeHandle< ATTR_TYPE > GetPerTetraAttribute(MeshType &m, std::string name=std::string(""))
gives a handle to a per-tetra attribute with a given name and ATTR_TYPE
Definition: allocate.h:2049
vcg::tri::Allocator::AddVertices
static VertexIterator AddVertices(MeshType &m, size_t n)
Wrapper to AddVertices(); no PointerUpdater.
Definition: allocate.h:262
vcg::tri::Allocator::AddHEdges
static HEdgeIterator AddHEdges(MeshType &m, size_t n, std::vector< HEdgePointer * > &local_vec)
Definition: allocate.h:530
vcg::tri::Allocator::AddVertices
static VertexIterator AddVertices(MeshType &m, size_t n, std::vector< VertexPointer * > &local_vec)
Wrapper to AddVertices() no PointerUpdater but a vector of VertexPointer pointers to be updated.
Definition: allocate.h:270
vcg::tri::Allocator::GetPerFaceAttribute
static MeshType::template ConstPerFaceAttributeHandle< ATTR_TYPE > GetPerFaceAttribute(const MeshType &m, std::string name=std::string(""))
gives a handle to a per-face attribute with a given name and ATTR_TYPE
Definition: allocate.h:1901
vcg::tri::Allocator::AddVertex
static VertexIterator AddVertex(MeshType &m, const CoordType &p)
Wrapper to AddVertices() to add a single vertex with given coords.
Definition: allocate.h:301
vcg::tri::Allocator::FindPerVertexAttribute
static MeshType::template ConstPerVertexAttributeHandle< ATTR_TYPE > FindPerVertexAttribute(const MeshType &m, const std::string &name)
Try to retrieve a const handle to an attribute with a given name and ATTR_TYPE, from the given const ...
Definition: allocate.h:1590
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template PerTetraAttributeHandle< ATTR_TYPE > &a)
Per Tetra Attributes.
Definition: allocate.h:1995
vcg::tri::Allocator::DeleteTetra
static void DeleteTetra(MeshType &m, TetraType &t)
Definition: allocate.h:974
vcg::tri::Allocator::AddEdges
static EdgeIterator AddEdges(MeshType &m, size_t n, PointerUpdater< EdgePointer > &pu)
Add n edges to the mesh. Function to add n edges to the mesh. The elements are added always to the en...
Definition: allocate.h:339
vcg::tri::Allocator::DeletePerEdgeAttribute
static void DeletePerEdgeAttribute(MeshType &m, typename MeshType::template PerEdgeAttributeHandle< ATTR_TYPE > &h)
If the per-edge attribute exists, delete it.
Definition: allocate.h:1800
vcg::tri::Allocator::AddVertex
static VertexIterator AddVertex(MeshType &m, const CoordType &p, const Color4b &c)
Wrapper to AddVertices() to add a single vertex with given coords and color.
Definition: allocate.h:320
vcg::tri::Allocator::AddVertex
static VertexIterator AddVertex(MeshType &m, const CoordType &p, const CoordType &n)
Wrapper to AddVertices() to add a single vertex with given coords and normal.
Definition: allocate.h:310
vcg::tri::Allocator::AddVertices
static VertexIterator AddVertices(MeshType &m, const Eigen::MatrixXf &vm)
Wrapper to AddVertices() to add an eigen matrix of (vn,3) it returns the iterator to the first vertex...
Definition: allocate.h:284
vcg::tri::Allocator::AddTetras
static TetraIterator AddTetras(MeshType &m, size_t n, std::vector< TetraPointer * > &local_vec)
Function to add n faces to the mesh. Second Wrapper, with a vector of face pointer to be updated.
Definition: allocate.h:913
vcg::tri::Allocator::CompactFaceVector
static void CompactFaceVector(MeshType &m, PointerUpdater< FacePointer > &pu)
Compact face vector by removing deleted elements.
Definition: allocate.h:1237
vcg::tri::Allocator::AddTetra
static TetraIterator AddTetra(MeshType &m, const CoordType &p0, const CoordType &p1, const CoordType &p2, const CoordType &p3)
Definition: allocate.h:857
vcg::tri::Allocator::DeletePerTetraAttribute
static void DeletePerTetraAttribute(MeshType &m, typename MeshType::template PerTetraAttributeHandle< ATTR_TYPE > &h)
If the per-face attribute exists, delete it.
Definition: allocate.h:2130
vcg::tri::Allocator::CompactFaceVector
static void CompactFaceVector(MeshType &m)
Wrapper without the PointerUpdater.
Definition: allocate.h:1343
vcg::tri::Allocator::DeleteFace
static void DeleteFace(MeshType &m, FaceType &f)
Definition: allocate.h:929
vcg::tri::Allocator::CompactVertexVector
static void CompactVertexVector(MeshType &m, PointerUpdater< VertexPointer > &pu)
Compact vector of vertices removing deleted elements. Deleted elements are put to the end of the vect...
Definition: allocate.h:1090
vcg::tri::Allocator::CompactEdgeVector
static void CompactEdgeVector(MeshType &m)
Wrapper without the PointerUpdater.
Definition: allocate.h:1224
vcg::tri::Allocator::AddHEdges
static HEdgeIterator AddHEdges(MeshType &m, size_t n)
Definition: allocate.h:521
vcg::tri::Allocator::GetPerEdgeAttribute
static MeshType::template PerEdgeAttributeHandle< ATTR_TYPE > GetPerEdgeAttribute(MeshType &m, std::string name=std::string(""))
gives a handle to a per-edge attribute with a given name and ATTR_TYPE
Definition: allocate.h:1721
vcg::tri::Allocator::DeleteVertex
static void DeleteVertex(MeshType &m, VertexType &v)
Definition: allocate.h:941
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template PerFaceAttributeHandle< ATTR_TYPE > &a)
Per Face Attributes.
Definition: allocate.h:1829
vcg::tri::Allocator::DeleteHEdge
static void DeleteHEdge(MeshType &m, HEdgeType &h)
Definition: allocate.h:963
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template ConstPerFaceAttributeHandle< ATTR_TYPE > &a)
Checks if a const handle to a Per-Face attribute is valid.
Definition: allocate.h:1841
vcg::tri::Allocator::AddFaces
static FaceIterator AddFaces(MeshType &m, size_t n, PointerUpdater< FacePointer > &pu)
Function to add n faces to the mesh. This is the only full featured function that is able to manage c...
Definition: allocate.h:671
vcg::tri::Allocator::CompactEdgeVector
static void CompactEdgeVector(MeshType &m, PointerUpdater< EdgePointer > &pu)
Compact vector of edges removing deleted elements.
Definition: allocate.h:1128
vcg::tri::Allocator::AddVertices
static VertexIterator AddVertices(MeshType &m, size_t n, PointerUpdater< VertexPointer > &pu)
Add n vertices to the mesh. Function to add n vertices to the mesh. The elements are added always to ...
Definition: allocate.h:195
vcg::tri::Allocator::GetPerFaceAttribute
static MeshType::template PerFaceAttributeHandle< ATTR_TYPE > GetPerFaceAttribute(MeshType &m, std::string name=std::string(""))
gives a handle to a per-face attribute with a given name and ATTR_TYPE
Definition: allocate.h:1884
vcg::tri::Allocator::AddFaces
static FaceIterator AddFaces(MeshType &m, const Eigen::MatrixXi &fm)
Function to add n faces to the mesh getting indexes from a (fn, 3) eigen matrix of int .
Definition: allocate.h:644
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template ConstPerVertexAttributeHandle< ATTR_TYPE > &a)
Checks if a const handle to a Per-Vertex Attribute is valid.
Definition: allocate.h:1488
vcg::tri::Allocator::CompactTetraVector
static void CompactTetraVector(MeshType &m)
Wrapper without the PointerUpdater.
Definition: allocate.h:1462
vcg::tri::Allocator::GetPerVertexAttribute
static MeshType::template PerVertexAttributeHandle< ATTR_TYPE > GetPerVertexAttribute(MeshType &m, std::string name=std::string(""))
gives a handle to a per-vertex attribute with a given name and ATTR_TYPE
Definition: allocate.h:1534
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template PerVertexAttributeHandle< ATTR_TYPE > &a)
Checks if a handle to a Per-Vertex Attribute is valid.
Definition: allocate.h:1476
vcg::tri::Allocator::AddFace
static FaceIterator AddFace(MeshType &m, CoordType p0, CoordType p1, CoordType p2)
Definition: allocate.h:573
vcg::tri::Allocator::CompactTetraVector
static void CompactTetraVector(MeshType &m, PointerUpdater< TetraPointer > &pu)
Compact tetra vector by removing deleted elements.
Definition: allocate.h:1356
vcg::tri::Allocator::DeletePerVertexAttribute
static void DeletePerVertexAttribute(MeshType &m, typename MeshType::template PerVertexAttributeHandle< ATTR_TYPE > &h)
If the per-vertex attribute exists, delete it.
Definition: allocate.h:1641
vcg::tri::Allocator::AddFaces
static FaceIterator AddFaces(MeshType &m, size_t n)
Function to add n faces to the mesh. First wrapper, with no parameters.
Definition: allocate.h:621
vcg::tri::Allocator::AddFaces
static FaceIterator AddFaces(MeshType &m, size_t n, std::vector< FacePointer * > &local_vec)
Function to add n faces to the mesh. Second Wrapper, with a vector of face pointer to be updated.
Definition: allocate.h:630
vcg::tri::Allocator::AddEdge
static EdgeIterator AddEdge(MeshType &m, VertexPointer v0, VertexPointer v1)
Definition: allocate.h:393
vcg::tri::Allocator::AddQuadFace
static FaceIterator AddQuadFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
Definition: allocate.h:591
vcg::tri::Allocator::GetPerMeshAttribute
static MeshType::template PerMeshAttributeHandle< ATTR_TYPE > GetPerMeshAttribute(MeshType &m, std::string name=std::string(""))
gives a handle to a per-edge attribute with a given name and ATTR_TYPE
Definition: allocate.h:2206
vcg::tri::Allocator::GetAllPerVertexAttribute
static void GetAllPerVertexAttribute(const MeshType &m, std::vector< std::string > &all)
query the mesh for all the attributes per vertex
Definition: allocate.h:1610
vcg::tri::Allocator::DeleteEdge
static void DeleteEdge(MeshType &m, EdgeType &e)
Definition: allocate.h:952
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template PerMeshAttributeHandle< ATTR_TYPE > &a)
Per Mesh Attributes.
Definition: allocate.h:2162
vcg::tri::Allocator::AddEdge
static EdgeIterator AddEdge(MeshType &m, CoordType p0, CoordType p1)
Definition: allocate.h:414
vcg::tri::Allocator::AddTetras
static TetraIterator AddTetras(MeshType &m, size_t n, PointerUpdater< TetraPointer > &pu)
Function to add n tetras to the mesh. This is the only full featured function that is able to manage ...
Definition: allocate.h:749
vcg::tri::Allocator::AddTetras
static TetraIterator AddTetras(MeshType &m, size_t n)
Function to add n faces to the mesh. First wrapper, with no parameters.
Definition: allocate.h:904
vcg::tri::Allocator::DeletePerMeshAttribute
static void DeletePerMeshAttribute(MeshType &m, typename MeshType::template PerMeshAttributeHandle< ATTR_TYPE > &h)
If the per-mesh attribute exists, delete it.
Definition: allocate.h:2278
vcg::tri::Allocator::AddTetra
static TetraIterator AddTetra(MeshType &m, const size_t v0, const size_t v1, const size_t v2, const size_t v3)
Definition: allocate.h:844
vcg::tri::Allocator::AddFace
static FaceIterator AddFace(MeshType &m, size_t v0, size_t v1, size_t v2)
Definition: allocate.h:563
vcg::tri::Allocator::CompactVertexVector
static void CompactVertexVector(MeshType &m)
Wrapper without the PointerUpdater.
Definition: allocate.h:1115
vcg::tri::Allocator::AddPerVertexAttribute
static MeshType::template PerVertexAttributeHandle< ATTR_TYPE > AddPerVertexAttribute(MeshType &m, std::string name)
Add a Per-Vertex Attribute of the given ATTR_TYPE with the given name.
Definition: allocate.h:1502
vcg::tri::Allocator::AddEdges
static EdgeIterator AddEdges(MeshType &m, size_t n, std::vector< EdgePointer * > &local_vec)
Definition: allocate.h:437
vcg::tri::Allocator::GetPerVertexAttribute
static MeshType::template ConstPerVertexAttributeHandle< ATTR_TYPE > GetPerVertexAttribute(const MeshType &m, std::string name=std::string(""))
gives a const handle to a per-vertex attribute with a given name and ATTR_TYPE
Definition: allocate.h:1551
vcg::tri::Allocator::AddFace
static FaceIterator AddFace(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2)
Definition: allocate.h:545
vcg::tri::Allocator::AddEdges
static EdgeIterator AddEdges(MeshType &m, size_t n)
Definition: allocate.h:428
vcg::tri::Allocator::AddTetra
static TetraIterator AddTetra(MeshType &m, VertexPointer v0, VertexPointer v1, VertexPointer v2, VertexPointer v3)
Definition: allocate.h:819
vcg::tri::Allocator::FindPerFaceAttribute
static MeshType::template ConstPerFaceAttributeHandle< ATTR_TYPE > FindPerFaceAttribute(const MeshType &m, const std::string &name)
Try to retrieve a const handle to an attribute with a given name and ATTR_TYPE, from the given const ...
Definition: allocate.h:1938
vcg::tri::Allocator::DeletePerFaceAttribute
static void DeletePerFaceAttribute(MeshType &m, typename MeshType::template PerFaceAttributeHandle< ATTR_TYPE > &h)
If the per-face attribute exists, delete it.
Definition: allocate.h:1970
vcg::tri::Allocator::FindPerVertexAttribute
static MeshType::template PerVertexAttributeHandle< ATTR_TYPE > FindPerVertexAttribute(MeshType &m, const std::string &name)
Try to retrieve an handle to an attribute with a given name and ATTR_TYPE.
Definition: allocate.h:1560
vcg::tri::Allocator::IsValidHandle
static bool IsValidHandle(const MeshType &m, const typename MeshType::template PerEdgeAttributeHandle< ATTR_TYPE > &a)
Per Edge Attributes.
Definition: allocate.h:1669
vcg::tri::Allocator::AddHEdges
static HEdgeIterator AddHEdges(MeshType &m, size_t n, PointerUpdater< HEdgePointer > &pu)
Definition: allocate.h:459
vcg::tri::Allocator::AddEdge
static EdgeIterator AddEdge(MeshType &m, size_t v0, size_t v1)
Definition: allocate.h:403
vcg
Definition: color4.h:30
Generated by doxygen 1.9.6 on Sun Oct 11 2026 08:44:55