Création de surfaces

Dans ce notebook, nous créons une surface (maillage) à partir d’un ensemble de données 3D d’une image binaire 3D simulée.

import napari_process_points_and_surfaces as nppas
import pyclesperanto_prototype as cle
import vedo

from branchoid import branchoid

binary_image = branchoid()
binary_image

shape (100, 100, 100) dtype uint8 size 976.6 kB min 0 max 1

Génération de surfaces

Nous générons d’abord une surface à partir de l’image binaire. Dans ce cas, nous prenons tous les pixels étiquetés non nuls et les transformons en une surface.

surface = nppas.all_labels_to_surface(binary_image)

L’objet résultant est visualisé dans les notebooks Jupyter comme ceci :

surface

nppas.SurfaceTuple origin (z/y/x) [0. 0. 0.] center of mass(z/y/x) 50.000,46.575,42.589 scale(z/y/x) 1.000,1.000,1.000 bounds (z/y/x) 25.500...74.500 2.500...88.500 2.500...83.500 average size 31.277 number of vertices 19040 number of faces 38076

Techniquement, c’est un tuple.

isinstance(surface, tuple)

True

Le tuple contient des sommets et des faces.

vertices, faces = surface

Les sommets sont des listes de listes de coordonnées Z/Y/X dans l’espace 3D.

vertices

array([[25.5, 44. , 47. ],
       [26. , 43.5, 47. ],
       [26. , 44. , 46.5],
       ...,
       [74.5, 56. , 51. ],
       [74.5, 56. , 52. ],
       [74.5, 56. , 53. ]], dtype=float32)

Les faces sont des listes de listes d’indices. Chaque triangle a trois coordonnées de points indexées comme ceci :

faces

array([[    2,     1,     0],
       [    4,     3,     0],
       [    4,     0,     1],
       ...,
       [19038, 18870, 18872],
       [19038, 18872, 19039],
       [19039, 18872, 18852]], dtype=int64)

Surfaces à partir d’étiquettes individuelles

Si nous avons une image étiquetée comme point de départ, nous pouvons également transformer des objets individuels en surfaces.

labels = cle.voronoi_otsu_labeling(binary_image, spot_sigma=6)
labels

cle._ image shape (100, 100, 100) dtype uint32 size 3.8 MB min 0.0 max 2.0

nppas.largest_label_to_surface(labels)

nppas.SurfaceTuple origin (z/y/x) [0. 0. 0.] center of mass(z/y/x) 50.000,53.374,48.714 scale(z/y/x) 1.000,1.000,1.000 bounds (z/y/x) 25.000...75.000 25.000...89.000 12.000...84.000 average size 28.026 number of vertices 8278 number of faces 16552

nppas.label_to_surface(labels, label_id=1)

nppas.SurfaceTuple origin (z/y/x) [0. 0. 0.] center of mass(z/y/x) 50.000,18.136,18.136 scale(z/y/x) 1.000,1.000,1.000 bounds (z/y/x) 36.000...64.000 2.000...38.000 2.000...38.000 average size 15.361 number of vertices 2472 number of faces 4952

nppas.label_to_surface(labels, label_id=2)

nppas.SurfaceTuple origin (z/y/x) [0. 0. 0.] center of mass(z/y/x) 50.000,53.374,48.714 scale(z/y/x) 1.000,1.000,1.000 bounds (z/y/x) 25.000...75.000 25.000...89.000 12.000...84.000 average size 28.026 number of vertices 8278 number of faces 16552

Création de surfaces avec vedo

Vedo offre également des fonctions pour créer des surfaces telles que iso_surface().

volume = vedo.Volume(binary_image)

iso_surface = volume.isosurface()
iso_surface

vedo.mesh.Mesh bounds (x/y/z) 25.33 ... 74.67 2.333 ... 88.67 2.333 ... 83.67 center of mass (50.0, 46.6, 42.6) average size 31.358 nr. points / faces 19040 / 38076 point data array input_scalars

La structure de données résultante est un maillage vedo. Vous pouvez également accéder à ses points et faces.

iso_surface.points()

array([[49.       , 11.       ,  2.3333333],
       [50.       , 11.       ,  2.3333333],
       [51.       , 11.       ,  2.3333333],
       ...,
       [50.       , 55.       , 83.666664 ],
       [51.       , 55.       , 83.666664 ],
       [52.       , 55.       , 83.666664 ]], dtype=float32)

iso_surface.faces()[:10]

[[0, 92, 104],
 [0, 1, 93],
 [92, 0, 93],
 [1, 2, 94],
 [93, 1, 94],
 [94, 2, 105],
 [3, 106, 118],
 [3, 4, 107],
 [106, 3, 107],
 [104, 107, 4]]

Exercice

Chargez le jeu de données skimage.data.cells3d, extrayez le deuxième canal et créez un maillage de surface à partir des noyaux.