Creación de superficies

En este notebook creamos una superficie (malla) a partir de un conjunto de datos 3D de una imagen binaria 3D simulada.

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

Generación de superficies

Primero generamos una superficie a partir de la imagen binaria. En este caso, tomamos todos los píxeles etiquetados que no son cero y los convertimos en una superficie.

surface = nppas.all_labels_to_surface(binary_image)

El objeto resultante se visualiza en los notebooks de Jupyter de esta manera:

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

Técnicamente, es una tupla.

isinstance(surface, tuple)

True

La tupla contiene vértices y caras.

vertices, faces = surface

Los vértices son listas de listas de coordenadas Z/Y/X en el espacio 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)

Las caras son listas de listas de índices. Cada triángulo tiene tres coordenadas de puntos indexadas de esta manera:

faces

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

Superficies a partir de etiquetas individuales

Si tenemos una imagen etiquetada como punto de partida, también podemos convertir objetos individuales en superficies.

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

Creación de superficies usando vedo

Vedo también ofrece funciones para crear superficies, como 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 estructura de datos resultante es una malla de vedo. También puedes acceder a sus puntos y caras.

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]]

Ejercicio

Carga el conjunto de datos skimage.data.cells3d, extrae el segundo canal y crea una malla de superficie a partir de los núcleos.