This mesher is used to generate a 3D surface mesh from a 3D segmented image.

The input is a 3D segmented binary image. It contains two values: voxels with a $0$ value are located outside of the object to mesh, voxels with a non-zero value are located inside.

The image must be .vtk, or event better .vti, which is more compact. If it is not the right format use Slicer3D, Paraview or my interface geniso/tools/gui4.py to change it.

First, the geniso tools must be loaded:

 import geniso.tools.generalTools as generalTools
 import geniso.tools.meshingTools as meshingTools
 import geniso.tools.imagingTools as imagingTools

Then the image must be loaded:

 image = generalTools.loadVtkImageXML(imageFileName)

Afterwards, the following set of commands is used to generate a surface mesh of the boundary of the segmented image:

 gen = GenerateMesh(generalTools.vtkImageDataToCpp(image)) 
 gen.execute() 
 smooth = SmoothMesh(gen.getSurf()) 
 smooth.smoothWithFctFromPoly(nbr,spx,spy,spz,nmin,interpol,type)

where the parameters are described in the table below.

In practice, GenerateMesh(image).execute() creates a triangulation of the boundary of the segmented object in the binary image given. Because of the spatial discretization of the image, the mesh which is generated is not smooth, since the steps of the image are kept. The class SmoothMesh() is used to eliminate these irregularities while keeping the geometry described in the image. It does so with the construction of an implicit function, described by the parameters nmin, interpol and type (for more details: http://hdl.handle.net/2268/136159).

Then, the vtkPolydata is retrieved with the command:

 poly = generalTools.genisoMeshToPolyData(smooth.getSurf())  

TetGen is used to get a tetrahedral volumic mesh of the object from the triangular surface mesh of the boundary of the object:

 ugrid = meshingTools.callTetgen(poly)

A vtkUnstructuredGrid is retrieved. To save it on disk: generalTools.saveUgridXML('ugrid.vtu',ugrid). Paraview is used to view it. The class LoadMesh, implemented in the file, is used to include it in a Metafor test case:

 groupset.add(Group(1))
 mesh = LoadMesh(domain, ugrid, groupset(1) )
 mesh.execute()

Cette option permet de générer un maillage qui contient plusieurs zones matérielles: un os qui contiendrait une partie os cortical et une partie os trabéculaire par exemple; un cerveau dans lequel les ventricules et une tumeur seraient séparés; une mâchoire avec une série de dents; …

Dans le cas multi-matériau l'image segmentée représentant la géométrie doit contenir plusieurs labels: 0 pour l'extérieur de l'objet (background) et une série de valeurs positives non nulles (typiquement 1,2,3,…) pour distinguer chacun des tissus.

Pour utiliser le mailleur GenIso, il faut tout d'abord définir la fonction implicite Fct, équivalente continue de l'image segmentée discrète, et qui permettra au mailleur de fournir une interface lisse entre les maillages séparant les différentes régions.

Pour définir cette fonction, on définit les couples de labels de l'image entre lesquels on veut que le mailleur crée une triangulation. De plus, on trie ces couples de manière à définir l'objet hétérogène comme un ensemble de closed surfaces sur lesquelles viennent éventuellement se greffer des open surfaces. Dans l'image ci-dessous, une tumeur (open surface défine par le couple (4,3) vient s'attacher sur la frontière extérieure du cerveau (closed surface définie par l'union des couples (3,0) et (4,0)).

Dès lors, la syntaxe à utiliser est la suivante:

  fct = Fct()
  surf1 = fct.defineClosedSurface()
  surf1.mesh(3,0)
  surf1.mesh(4,0)
  surf2 = fct.defineOpenSurface()
  surf2.mesh(4,3)
  fct.setEpsilon(eps)
  fct.setNmin(nmin)
  fct.setType(type)
  fct.setInterpol(interpol)
  fct.setVtkImageFromPython(generalTools.vtkImageDataToCpp(image))
  fct.build()

Ensuite, nous pouvons générer le maillage au moyen des commandes:

  gen = GenerateMesh(fct)
  gen.getRegularGrid().setResolution(res)
  gen.execute()
  poly = generalTools.genisoMeshToPolyData(gen.getSurf()) // vtkPolyData

A partir de ce maillage surfacique multi-régions, on utilise TetGen pour générer le maillage volumique dans chacune des régions définies. Pour ce faire il faut spécifier à TetGen un point, seed, situé dans chacune des régions à mailler volumiquement (vous pouvez par exemple aller chercher ce point en chargeant le vtkPolyData dans l'interface graphique geniso/tools/gui4.py et en utilisant ensuite l'option point ).

  seedbrain= [118.3,160.5,75]
  seedtumor = [118,196.9,71]
  regionSeeds = [seedbrain,seedtumor]
  regionVolmax = [volmax, volmax]
  ugrid = meshingTools.callTetgenMultipleRegions(poly, regionSeeds, regionVolmax)

Ensuite, pour charger le maillage dans Metafor:

  labels = [1,2]  // les deux labels des régions dans l'ugrid (cfr. visu dans Paraview)
  grp = [groupset(1),groupset(2)] 
  
  mesh = tetgen.LoadMesh(domain, ugrid, grp)
  mesh.setFillMeshPoints(True)
  mesh.setGrpLabels(labels)
  mesh.execute()