aimsalgo  5.1.2
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 
53 namespace 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
BucketMap< Void >::setSizeX
void setSizeX(float sizex)
BucketMap< Void >::setSizeY
void setSizeY(float sizey)
BucketMap< Void >::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::GetListePoints
std::set< T, ltstr_p3d< T > > & GetListePoints()
Definition: greyLevelBlob.h:155
iterator
T * iterator
aims::SurfaceGenerator::cylinder
static AimsSurfaceTriangle * cylinder(const carto::GenericObject &params)
aims::SurfaceGenerator::sphere
static AimsSurfaceTriangle * sphere(const carto::GenericObject &params)
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::VolumeRef::begin
iterator begin()
carto::rc_ptr
aims::meshdistance::min
float min(float x, float y)
Definition: thickness.h:106
aims::meshdistance::max
float max(float x, float y)
Definition: thickness.h:98
aims::GetSSBlobMeshBucket
AimsBucket< Void > * GetSSBlobMeshBucket(AimsSurfaceTriangle *mesh)
Definition: primalSketchUtil.h:334
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::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