aimsalgo 6.0.0
Neuroimaging image processing
primalSketchUtil.h
Go to the documentation of this file.
1/* This software and supporting documentation are distributed by
2 * Institut Federatif de Recherche 49
3 * CEA/NeuroSpin, Batiment 145,
4 * 91191 Gif-sur-Yvette cedex
5 * France
6 *
7 * This software is governed by the CeCILL-B license under
8 * French law and abiding by the rules of distribution of free software.
9 * You can use, modify and/or redistribute the software under the
10 * terms of the CeCILL-B license as circulated by CEA, CNRS
11 * and INRIA at the following URL "http://www.cecill.info".
12 *
13 * As a counterpart to the access to the source code and rights to copy,
14 * modify and redistribute granted by the license, users are provided only
15 * with a limited warranty and the software's author, the holder of the
16 * economic rights, and the successive licensors have only limited
17 * liability.
18 *
19 * In this respect, the user's attention is drawn to the risks associated
20 * with loading, using, modifying and/or developing or reproducing the
21 * software by the user in light of its specific status of free software,
22 * that may mean that it is complicated to manipulate, and that also
23 * therefore means that it is reserved for developers and experienced
24 * professionals having in-depth computer knowledge. Users are therefore
25 * encouraged to load and test the software's suitability as regards their
26 * requirements in conditions enabling the security of their systems and/or
27 * data to be ensured and, more generally, to use and operate it in the
28 * same conditions as regards security.
29 *
30 * The fact that you are presently reading this means that you have had
31 * knowledge of the CeCILL-B license and that you accept its terms.
32 */
33
34
35#ifndef AIMS_PRIMALSKETCH_PRIMALSKETCHUTIL_H
36#define AIMS_PRIMALSKETCH_PRIMALSKETCHUTIL_H
37
38#include <cstdlib>
39#include <aims/config/aimsalgo_config.h>
40#include <aims/primalsketch/primalSketch.h>
41#include <aims/bucket/bucket.h>
42#include <aims/graph/graphmanip.h>
43#include <aims/mesh/surfacegen.h>
44#include <aims/mesh/surfaceOperation.h>
45#include <unistd.h>
46#include <graph/graph/graph.h>
47#include <set>
48#include <map>
49#include <list>
50#include <utility>
51#include <math.h>
52
53namespace aims
54{
55 // Functions that deal with primal sketches
56
57 //------------------------------------- Declarations ----------------------------------------------------------------
58
59 template<typename T> carto::VolumeRef<short> *GetSSBlobImage(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch);
60 template<int D, class T> TimeTexture<float> GetSSBlobTexture(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch);
61 template<int D, class T> AimsSurfaceTriangle *GetSSBlobMesh(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch);
62
63 template<typename T> AimsBucket<Void> *GetSSBlobBucket(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch);
64 template<int D, class T> AimsSurfaceTriangle *GetSSBlobTore(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch);
65
66 template<typename Geom, typename Text> void AddBlobsToPSGraph(PrimalSketch<Geom,Text> *sketch, Graph *graph);
67 template<typename T> void AddBlobsToPSGraph(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch, Graph *graph);
68 template<int D, class T> void AddBlobsToPSGraph(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch, Graph *graph);
69
70 //------------------------------------ Definitions ------------------------------------------------------------------
71
72 template<typename T> carto::VolumeRef<short> *GetSSBlobImage(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch)
73 {
74 typedef Point3d Site;
75
76 carto::VolumeRef<short> *image;
77 int x,y,z,sx,sy,sz, i;
78 std::list<ScaleSpaceBlob<Site>*> ssBlobList=sketch->BlobSet();
79 std::list<ScaleSpaceBlob<Site>*>::iterator itBlob=ssBlobList.begin();
80 GreyLevelBlob<Site> *glBlob;
81 std::set<Site,ltstr_p3d<Site> > points;
82 std::set<Site,ltstr_p3d<Site> >::iterator itPoints;
83
84 sx=sketch->scaleSpace()->GetOriginalImage().getSizeX();
85 sy=sketch->scaleSpace()->GetOriginalImage().getSizeY();
86 sz=sketch->scaleSpace()->GetOriginalImage().getSizeZ();
87
88 image=new carto::VolumeRef<short>(sx, sy, sz);
89 image->setVoxelSize(
90 sketch->scaleSpace()->GetOriginalImage().getVoxelSize() );
91
92 for (z=0; z<sz; z++)
93 for (y=0; y<sy; y++)
94 for (x=0; x<sx; x++)
95 (*image)(x,y,z)=0;
96
97 for (; itBlob!=ssBlobList.end(); ++itBlob)
98 {
99 glBlob=(*itBlob)->GlBlobRep();
100 points=glBlob->GetListePoints();
101 itPoints=points.begin();
102 for (; itPoints!=points.end(); ++itPoints)
103 {
104 x=(*itPoints)[0]; y=(*itPoints)[1]; z=(*itPoints)[2];
105 if ((i=(*image)(x,y,z))==0)
106 (*image)(x,y,z)=100 + ((*itBlob)->Label() * 10);
107 else
108 (*image)(x,y,z)=105 + ((*itBlob)->Label() * 10);
109 }
110 }
111
112 return image;
113 }
114
115
116 //------------------------------------------------------------------------------------------
117
118 template<int D, class T> TimeTexture<float> GetSSBlobTexture(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch)
119 {
120 typedef std::pair<Point3df,uint> Site;
121
122 //TexturedData<AimsSurface<D, Void>, Texture<T> > *textBlob;
123 std::list<ScaleSpaceBlob<Site>*> ssBlobList=sketch->BlobSet();
124 std::list<ScaleSpaceBlob<Site>*>::iterator itBlob=ssBlobList.begin();
125 GreyLevelBlob<Site> *glBlob;
126 std::set<Site,ltstr_p3d<Site> > points;
127 std::set<Site,ltstr_p3d<Site> >::iterator itPoints;
128 //int label;
129
130 //textBlob=new TexturedData<AimsSurface<D, Void>, Texture<T> >(sketch->scaleSpace()->Mesh(), &(sketch->scaleSpace()->GetOriginalImage()));
131
132 std::set<float> scale= sketch->scaleSpace()->GetScaleList();
133
134
135 TimeTexture<float> tex(scale.size(),sketch->scaleSpace()->Mesh()->vertex().size());
136 for (uint i=0;i<scale.size();i++)
137 for (uint j=0;j<sketch->scaleSpace()->Mesh()->vertex().size();j++)
138 tex[i].item(j)=0;
139
140 float sc = 0.0f;
141 std::set<float>::iterator it;
142 uint test=0;
143 uint i=0;
144 for (; itBlob!=ssBlobList.end(); ++itBlob)
145 {
146 //label=(*itBlob)->Label();
147 glBlob=(*itBlob)->GlBlobRep();
148 points=glBlob->GetListePoints();
149 itPoints=points.begin();
150// if (points.size() == 1){
151 std::list<GreyLevelBlob<Site>*> glBlobs=(*itBlob)->glBlobs;
152 std::list<GreyLevelBlob<Site>*>::iterator glit;
153 for (glit = glBlobs.begin() ; glit != glBlobs.end() ; glit++){
154 points=(*glit)->GetListePoints();
155 itPoints=points.begin();
156 sc = (*glit)->GetScale();
157 for (i=0,it=scale.begin();
158 *it != sc && it!=scale.end();it++,i++) {}
159
160 for (; itPoints!=points.end(); ++itPoints)
161 {
162 tex[i].item((*itPoints).second)= (*itBlob)->GetMeasurements().t; //100+test*10;
163 }
164 }
165 test++;
166// }
167// uint i=0;
168// float delta=1000.0;
169// for (it=scale.begin();it!=scale.end();it++){
170// if (fabs(*it-(*itBlob)->ScaleRep()) < delta)
171// {
172// delta=fabs(*it-(*itBlob)->ScaleRep());
173// sc = *it;
174// }
175// }
176// cout << "sc:" << sc << " ";
177 for (i=0,it=scale.begin();*it != sc && it!=scale.end();
178 it++,i++) {}
179
180 }
181
182 return tex;
183// return textBlob->GetTexture();
184 }
185
186 //------------------------------------------------------------------------------------------
187
188 template<typename T> AimsBucket<Void> *GetSSBlobBucket(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch)
189 {
190 typedef Point3d Site;
191 AimsBucket<Void> *blobBck;
192 float dx, dy, dz;
193 std::list<ScaleSpaceBlob<Site>*> ssBlobList=sketch->BlobSet();
194 std::list<ScaleSpaceBlob<Site>*>::iterator itBlob=ssBlobList.begin();
195 GreyLevelBlob<Site> *glBlob;
196 std::set<Site,ltstr_p3d<Site> > points;
197 std::set<Site,ltstr_p3d<Site> >::iterator itPoints;
198 AimsBucketItem<Void> bckItem;
199
200 dx=sketch->scaleSpace()->GetOriginalImage().getVoxelSize()[0];
201 dy=sketch->scaleSpace()->GetOriginalImage().getVoxelSize()[1];
202 dz=sketch->scaleSpace()->GetOriginalImage().getVoxelSize()[2];
203
204 blobBck=new AimsBucket<Void>;
205 blobBck->setSizeX(dx);
206 blobBck->setSizeY(dy);
207 blobBck->setSizeZ(dz);
208
209 for (; itBlob!=ssBlobList.end(); ++itBlob)
210 {
211 glBlob=(*itBlob)->GlBlobRep();
212 points=glBlob->GetListePoints();
213 itPoints=points.begin();
214 for (; itPoints!=points.end(); ++itPoints)
215 {
216 bckItem.location()=(*itPoints);
217 (*blobBck)[(*itBlob)->Label()].push_back(bckItem);
218 }
219 }
220 return blobBck;
221 }
222
223 //------------------------------------------------------------------------------------------
224 template<int D, class T> AimsSurfaceTriangle *GetSSBlobMesh(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch, AimsSurfaceTriangle *mesh)
225 {
226 typedef std::pair<Point3df,uint> Site; // ATTENTION : cette fonction ne marche que pour les surfaces triangulees
227 // et pas pour D quelconque. C'est un peu verole mais bon...
228 // Peut-?tre le primalSketch de surfaces devrait-il ?tre limit? aux triangulations
229 AimsSurfaceTriangle *meshBlob;
230 std::list<ScaleSpaceBlob<Site>*> ssBlobList=sketch->BlobSet();
231 std::list<ScaleSpaceBlob<Site>*>::iterator ssblobit=ssBlobList.begin();
232 std::set<Site,ltstr_p3d<Site> > points;
233
234 std::map<int,int> tableNodes;
235 int label, index;
236 uint count=0, count2=0;
237 Point3df coord;
238 AimsTimeSurface<3,Void> oneMesh, tempMesh;
239 std::vector<Point3df> nodes;
240 std::vector<Point3dd> pts;
241 std::vector< AimsVector<uint,3> > poly, allPoly;
242 std::vector< AimsVector<uint,3> >::iterator itPoly;
243 AimsVector<uint,3> tri;
244
245 meshBlob=new AimsSurfaceTriangle();
246 (*mesh)[0].updateNormals();
247
248 std::cout << "==============================" << std::endl;
249 for (; ssblobit!=ssBlobList.end(); ++ssblobit ) { // ON PARCOURT LES SSBLOBS
250 oneMesh=AimsSurfaceTriangle();
251 label=(*ssblobit)->Label();
252
253 std::cout << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\bssb n°" << label << "("<< count2++ <<"/" << ssBlobList.size()<<") " << std::flush;
254
255 std::list<GreyLevelBlob<Site>*>::iterator glblobit=(*ssblobit)->glBlobs.begin();
256 std::map<float,GreyLevelBlob<Site>*> glblobmap;
257 for (;glblobit != (*ssblobit)->glBlobs.end();glblobit++){
258 glblobmap[(*glblobit)->GetScale()] = *glblobit;
259 }
260 std::map<float,GreyLevelBlob<Site>*>::iterator mapit=glblobmap.begin();
261
262 for (count = 0;count<1 && count <glblobmap.size();count++,mapit++){ // ON PARCOURT LES GLBLOBS DU SSB
263 tempMesh=AimsSurfaceTriangle();
264 tableNodes.clear();
265 points=(*mapit).second->GetListePoints();
266 points=(*ssblobit)->GlBlobRep()->GetListePoints();
267 std::set<Site,ltstr_p3d<Site> >::iterator itPoints=points.begin();
268 std::set<uint> auxpts;
269 for (; itPoints!=points.end(); ++itPoints){
270 index=(*itPoints).second;
271 auxpts.insert(index);
272 }
273 for (uint i=0; i<(*mesh)[0].polygon().size(); i++){
274 if ((auxpts.find((*mesh)[0].polygon()[i][0]) != auxpts.end()) // si le polytgone ne contient que des
275 && (auxpts.find((*mesh)[0].polygon()[i][1]) != auxpts.end()) // points du blob
276 && (auxpts.find((*mesh)[0].polygon()[i][2]) != auxpts.end())){ // on le garde
277 for (uint j=0;j<3;j++){
278 Point3df node((*mesh)[0].vertex()[(*mesh)[0].polygon()[i][j]]);
279 Point3df norm((*mesh)[0].normal()[(*mesh)[0].polygon()[i][j]]);
280 norm *= 0.01;
281 node += norm;
282 tempMesh[0].vertex().push_back(Point3df(node[0],node[1],node[2]));
283 }
284 tempMesh[0].polygon().push_back(AimsVector<uint,3>( tempMesh[0].vertex().size()-3,tempMesh[0].vertex().size()-2,tempMesh[0].vertex().size()-1));
285 }
286 }
287
288 // JUSTE LES CYLINDRES DE LIAISON
289// if ((*ssblobit)->TopBifurcation()->Type() != APPEAR){
290// AimsSurfaceTriangle *msh;
291// std::list<ScaleSpaceBlob<Site>*> topblobs = (*ssblobit)->TopBifurcation()->TopBlobs();
292// Point3df v1 = (*mesh).vertex()[(*ssblobit)->GlBlobRep()->GetMaximum()->_node.second];
293// Point3df n1 = (*mesh).normal()[(*ssblobit)->GlBlobRep()->GetMaximum()->_node.second];
294// n1 *= (*mapit).second->GetScale()*3;
295// v1 += n1;
296// std::list<ScaleSpaceBlob<Site>*>::iterator ittb=topblobs.begin();
297// for (; ittb !=topblobs.end();++ittb){
298// Point3df v2 = (*mesh).vertex()[(*ittb)->GlBlobRep()->GetMaximum()->_node.second];
299// Point3df n2 = (*mesh).normal()[(*ittb)->GlBlobRep()->GetMaximum()->_node.second];
300// n2 *= (*ittb)->ScaleMin();
301// v2 += n2;
302// msh = SurfaceGenerator::cylinder(v1 ,v2 , 0.1, 0.1, 6,true,true );
303// SurfaceManip::meshMerge( tempMesh, *msh );
304// }
305// }
306//
307 SurfaceManip::meshMerge( oneMesh, tempMesh );
308 }
309
310
311 if (oneMesh[0].polygon().size()!=0){
312 (*meshBlob)[label]=AimsSurface<3,Void>();
313 (*meshBlob)[label].polygon()=oneMesh[0].polygon();
314 (*meshBlob)[label].vertex()=oneMesh[0].vertex();
315 (*meshBlob)[label].updateNormals();
316 }
317 else {
318// if (true){
319 AimsSurfaceTriangle *msh;
320 Point3df auxnode = (*mesh)[0].vertex()[(*ssblobit)->GlBlobRep()->GetMaximum()->_node.second];
321 msh = SurfaceGenerator::sphere(auxnode , 0.5,6 );
322 (*meshBlob)[label]=AimsSurface<3,Void>();
323 (*meshBlob)[label].polygon()=(*msh).polygon();
324 (*meshBlob)[label].vertex()=(*msh).vertex();
325 (*meshBlob)[label].updateNormals();
326 }
327
328 }
329 std::cout << "END" << std::endl;
330
331 return meshBlob;
332 }
333
334 template<typename T> AimsBucket<Void> *GetSSBlobMeshBucket(AimsSurfaceTriangle *mesh)
335 {
336 AimsBucket<Void> *blobBck;
337 AimsBucketItem<Void> bckItem;
338
339 blobBck=new AimsBucket<Void>;
340 blobBck->setSizeX(1.0);
341 blobBck->setSizeY(1.0);
342 blobBck->setSizeZ(1.0);
343
344 for (uint i=0; i<(*mesh).size(); i++) {
345 for (uint j=0; j<(*mesh)[i].vertex().size(); j++)
346 {
347 bckItem.location()=static_cast<Point3d>((*mesh)[i].vertex()[j]);
348 (*blobBck)[i].push_back(bckItem);
349 }
350 }
351 return blobBck;
352 }
353
354
355 //------------------------------------------------------------------------------------------
356 template<typename Geom, typename Text> void AddBlobsToPSGraph(PrimalSketch<Geom,Text> *sketch, Graph *graph)
357 {
358 }
359
360
361 //------------------------------------------------------------------------------------------
362 template<typename T> void AddBlobsToPSGraph(PrimalSketch<carto::VolumeRef<T>, carto::VolumeRef<T> > *sketch, Graph *graph) {
363 std::set<Vertex * > vertSet;
364 std::set<Vertex *>::iterator itVert;
365 Vertex *node;
366 BucketMap<Void> *bckMap;
367 int label;
368 aims::GraphManip manip;
369 carto::rc_ptr<BucketMap<Void> > ptrBck;
370 std::vector<int> bounding_min, bounding_max;
371 std::vector<float> resolution;
372
373 bounding_min.push_back(0);
374 bounding_min.push_back(0);
375 bounding_min.push_back(0);
376 bounding_max.push_back(sketch->scaleSpace()->GetOriginalImage().getSizeX());
377 bounding_max.push_back(sketch->scaleSpace()->GetOriginalImage().getSizeY());
378 bounding_max.push_back(sketch->scaleSpace()->GetOriginalImage().getSizeZ());
379 resolution = sketch->scaleSpace()->GetOriginalImage().getVoxelSize();
380
381 graph->setProperty( "boundingbox_min", bounding_min );
382 graph->setProperty( "boundingbox_max", bounding_max );
383 graph->setProperty( "voxel_size", resolution );
384
385 bckMap = new BucketMap<Void>( *GetSSBlobBucket(sketch) );
386 bckMap->setSizeX( resolution[0] );
387 bckMap->setSizeY( resolution[1] );
388 bckMap->setSizeZ( resolution[2] );
389 vertSet = graph->vertices();
390 for ( itVert = vertSet.begin() ; itVert != vertSet.end() ; ++itVert ) {
391 node =*itVert;
392 node->getProperty( "index", label );
393 ptrBck=carto::rc_ptr<BucketMap<Void> >( new BucketMap<Void> );
394 (*ptrBck)[0] = (*bckMap)[label];
395 ptrBck->setSizeX( resolution[0] );
396 ptrBck->setSizeY( resolution[1] );
397 ptrBck->setSizeZ( resolution[2] );
398 manip.storeAims( *graph, node, "ssblob", ptrBck );
399 node->setProperty( "ssblob_label", label );
400 }
401 }
402
403 //------------------------------------------------------------------------------------------
404 template<int D, class T> void AddBlobsToPSGraph(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch, Graph *graph){
405 std::set<Vertex * > vertSet;
406 std::set<Vertex *>::iterator itVert;
407 Vertex *node;
408 AimsSurfaceTriangle *tore;
409 BucketMap<Void> *bckMap;
410
411 int label;
412 aims::GraphManip manip;
413 carto::rc_ptr<AimsSurfaceTriangle> ptrTore;
414 carto::rc_ptr<BucketMap<Void> > ptrBck;
415
416 std::vector<int> bounding_min, bounding_max;
417 std::vector<float> bounding_minf, bounding_maxf;
418 std::vector<float> resolution;
419 Point3df mini, maxi;
420
421 AimsSurfaceTriangle *mesh;
422 mesh = new AimsSurfaceTriangle();
423
424 if (sketch->scaleSpace()->AuxMesh() != NULL){
425 mesh = sketch->scaleSpace()->AuxMesh();
426 }
427 else {
428 AimsSurface<3,Void> auxsurf(*(sketch->scaleSpace()->Mesh()));
429 (*mesh)[0] = auxsurf;
430 }
431
432 for (uint z=0;z<3;z++){ mini[z] = 100000000.0; maxi[z] = -100000000.0; }
433
434 for (uint i=0;i<(*mesh)[0].vertex().size();i++)
435 for (uint z=0;z<3;z++){
436 mini[z] = std::min((*mesh)[0].vertex()[i][z], mini[z]);
437 maxi[z] = std::max((*mesh)[0].vertex()[i][z], maxi[z]);
438 }
439
440 resolution.push_back(1);
441 resolution.push_back(1);
442 resolution.push_back(1);
443 bounding_min.push_back(-1);
444 bounding_min.push_back(-1);
445 bounding_min.push_back(-1);
446 bounding_max.push_back(1);
447 bounding_max.push_back(1);
448 bounding_max.push_back(1);
449 graph->setProperty("boundingbox_min", bounding_min);
450 graph->setProperty("boundingbox_max", bounding_max);
451 graph->setProperty("voxel_size", resolution);
452
453 tore=GetSSBlobMesh(sketch, mesh);
454 bckMap=new BucketMap<Void>();
455 bckMap->setSizeX(resolution[0]);
456 bckMap->setSizeY(resolution[1]);
457 bckMap->setSizeZ(resolution[2]);
458 vertSet=graph->vertices();
459
460 for (itVert=vertSet.begin(); itVert!=vertSet.end(); ++itVert){
461 node=*itVert;
462 node->getProperty("index", label);
463 // Rajouter le bckMap[label] dans les attributs
464 ptrTore=carto::rc_ptr<AimsSurfaceTriangle>(new AimsSurfaceTriangle);
465 (*ptrTore)[0]=(*tore)[label];
466// for (uint j=0; j< (*tore)[label].vertex().size(); j++){
467// pair<Point3d,Void> aux;
468// aux.first = Point3d((int)(((*tore)[label].vertex()[j][0]+resolution[0]/2.0)/resolution[0]),(int)(((*tore)[label].vertex()[j][1]+resolution[1]/2.0)/resolution[1]),(int)(((*tore)[label].vertex()[j][2]+resolution[2]/2.0)/resolution[2]));
469// (*bckMap)[label].insert(aux);
470// }
471
472 manip.storeAims( *graph, node, "ssblob", ptrTore );
473 ptrBck=carto::rc_ptr<BucketMap<Void> >(new BucketMap<Void>);
474
475 (*ptrBck)[0]=(*bckMap)[label];
476 ptrBck->setSizeX(resolution[0]);
477 ptrBck->setSizeY(resolution[1]);
478 ptrBck->setSizeZ(resolution[2]);
479// manip.storeAims( *graph, node, "ssblobbucket", ptrBck );
480// node->setProperty("ssblobbucket_label", label);
481 node->setProperty("ssblob_label", label);
482 }
483
484 }
485
486 //------------------------------------------------------------------------------------------
487 template<int D, class T> AimsSurfaceTriangle *GetSSBlobTore(PrimalSketch<AimsSurface<D, Void>, Texture<T> > *sketch)
488 {
489 AimsSurfaceTriangle *blobMesh, *blobTore;
490
491
492 blobMesh=GetSSBlobMesh(sketch);
493
494 // Code from here is a simple extension from the ScaleSpace::surface2Tore function
495 // by Arnaud Cachia
496
497 unsigned i, t=0, p, t1, t2, t3;
498 //AimsSurfaceTriangle::iterator itMesh;
499 unsigned nedge = 0;
500 AimsSurfaceTriangle *msh, *tmpMesh;
501
502 blobTore=new AimsSurfaceTriangle;
503
504 //for (itMesh==blobMesh->begin();itMesh!=blobMesh->end();++itMesh)
505 for (t=0; t<blobMesh->size(); t++)
506 {
507 const std::vector<Point3df> vert = (*blobMesh)[t].vertex();
508 const std::vector<AimsVector<uint,3> > poly = (*blobMesh)[t].polygon();
509 std::map<std::pair<unsigned, unsigned>, unsigned> edges;
510 std::map<std::pair<unsigned, unsigned>, unsigned>::iterator ie, eie = edges.end();
511 p = poly.size();
512
513 for( i=0; i<p; ++i )
514 {
515 t1 = poly[i][0];
516 t2 = poly[i][1];
517 t3 = poly[i][2];
518
519 if( t1 < t2 )
520 ++edges[ std::pair<unsigned, unsigned>( t1, t2 ) ];
521 else
522 ++edges[ std::pair<unsigned, unsigned>( t2, t1 ) ];
523 if( t1 < t3 )
524 ++edges[ std::pair<unsigned, unsigned>( t1, t3 ) ];
525 else
526 ++edges[ std::pair<unsigned, unsigned>( t3, t1 ) ];
527 if( t2 < t3 )
528 ++edges[ std::pair<unsigned, unsigned>( t2, t3 ) ];
529 else
530 ++edges[ std::pair<unsigned, unsigned>( t3, t2 ) ];
531 }
532
533 tmpMesh=new AimsSurfaceTriangle;
534 for( ie=edges.begin(); ie!=eie; ++ie)
535 if( (*ie).second == 1 )
536 {
537 ++nedge;
538 msh = SurfaceGenerator::cylinder( vert[(*ie).first.first], vert[(*ie).first.second], 0.3, 0.3, 3, false );
539 SurfaceManip::meshMerge( *tmpMesh, *msh );
540 delete msh;
541 }
542 (*blobTore)[t]=(*tmpMesh)[0];
543 delete tmpMesh;
544 }
545
546 return( blobTore );
547 }
548
549}
550
551#endif
aimsalgo_config.h
AimsBucketItem::location
const AimsVector< short, 3 > & location() const
AimsBucket::setSizeX
void setSizeX(float sizex)
AimsBucket::setSizeY
void setSizeY(float sizey)
AimsBucket::setSizeZ
void setSizeZ(float sizez)
AimsTimeSurface::polygon
const std::vector< AimsVector< uint, D > > & polygon() const
AimsTimeSurface::vertex
const std::vector< Point3df > & vertex() const
Graph::vertices
const std::set< Vertex * > & vertices() const
TimeTexture::item
const T & item(int n) const
aims::BucketMap::setSizeX
void setSizeX(float sizex)
aims::BucketMap::setSizeY
void setSizeY(float sizey)
aims::BucketMap::setSizeZ
void setSizeZ(float sizez)
aims::GraphManip::storeAims
static void storeAims(Graph &graph, GraphObject *vertex, const std::string &attribute, carto::rc_ptr< T > obj)
aims::GreyLevelBlob
Class for grey-level blobs Templated with respect to the type of points: TypeSite<carto::VolumeRef<T>...
Definition greyLevelBlob.h:119
aims::GreyLevelBlob::GetListePoints
std::set< T, ltstr_p3d< T > > & GetListePoints()
Definition greyLevelBlob.h:155
aims::SurfaceManip::meshMerge
static void meshMerge(AimsTimeSurface< D, T > &dst, const AimsTimeSurface< D, T > &add)
carto::VolumeRef::setVoxelSize
void setVoxelSize(float vx, float vy=1., float vz=1., float vt=1.)
carto::rc_ptr
aims::GetSSBlobMesh
AimsSurfaceTriangle * GetSSBlobMesh(PrimalSketch< AimsSurface< D, Void >, Texture< T > > *sketch)
aims::GetSSBlobTexture
TimeTexture< float > GetSSBlobTexture(PrimalSketch< AimsSurface< D, Void >, Texture< T > > *sketch)
Definition primalSketchUtil.h:118
aims::GetSSBlobTore
AimsSurfaceTriangle * GetSSBlobTore(PrimalSketch< AimsSurface< D, Void >, Texture< T > > *sketch)
Definition primalSketchUtil.h:487
aims::GetSSBlobBucket
AimsBucket< Void > * GetSSBlobBucket(PrimalSketch< carto::VolumeRef< T >, carto::VolumeRef< T > > *sketch)
Definition primalSketchUtil.h:188
aims::GetSSBlobImage
carto::VolumeRef< short > * GetSSBlobImage(PrimalSketch< carto::VolumeRef< T >, carto::VolumeRef< T > > *sketch)
Definition primalSketchUtil.h:72
aims::GetSSBlobMeshBucket
AimsBucket< Void > * GetSSBlobMeshBucket(AimsSurfaceTriangle *mesh)
Definition primalSketchUtil.h:334
aims::AddBlobsToPSGraph
void AddBlobsToPSGraph(PrimalSketch< Geom, Text > *sketch, Graph *graph)
Definition primalSketchUtil.h:356
AimsSurfaceTriangle
AIMSDATA_API AimsTimeSurface< 3, Void > AimsSurfaceTriangle
norm
AIMSDATA_API float norm(const Tensor &thing)
uint
unsigned int uint
Point3df
AimsVector< float, 3 > Point3df
Point3d
AimsVector< int16_t, 3 > Point3d