Estadísticas descriptivas de [muchas] líneas en una imagen

Al estudiar la intensidad a lo largo de muchas líneas en una imagen, esto se puede hacer en paralelo en una GPU. Este notebook demuestra esto usando solo dos líneas con fines ilustrativos. Se puede asumir que la lectura de cientos o miles de líneas en paralelo tiene sentido en términos de rendimiento en las GPUs.

import pyclesperanto_prototype as cle
from skimage.data import cells3d
import numpy as np

Para demostrar un caso de uso potencial, examinamos de cerca una imagen de células que expresan un marcador de membrana.

membranes = cells3d()[30, 0, 110:150, 110:150]
cle.imshow(membranes)

Definimos las coordenadas de cuatro puntos que se conectarán en dos líneas. La conexión se realizará utilizando una matriz de contacto que permite conectar n puntos con n puntos.

coords = np.asarray([
    [0, 17],  # line 1 start (x, y)
    [10, 24], # line 1 end
    [20, 21], # line 2
    [35, 21]
]).T

connection_matrix = cle.symmetric_maximum_matrix(np.asarray([
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0], # this connects the two points of line 1
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 1], # this connects the two points of line 2
    [0, 0, 0, 0, 0]
]))
connection_matrix

cle.array([[0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 0. 0. 1.]
 [0. 0. 0. 1. 0.]], dtype=float32)

Primero visualizamos estas líneas sobre la imagen de la membrana.

mesh = cle.create_like(membranes)
mesh = cle.touch_matrix_to_mesh(coords, connection_matrix, mesh)

cle.imshow(membranes, continue_drawing=True)
cle.imshow(mesh, alpha=0.5, colormap='jet')

Medir la intensidad media a lo largo de las líneas

A continuación, usamos la matriz configurada anteriormente para medir la intensidad media promedio a lo largo de las líneas. También necesitamos especificar cuántas muestras se tomarán a lo largo de las líneas.

num_samples = 10

mean_intensity_matrix = cle.generate_mean_intensity_between_points_matrix(
                                membranes, coords, connection_matrix, num_samples=num_samples)
mean_intensity_matrix

cle.array([[   0.     0.     0.     0.     0. ]
 [   0.     0.  7317.8    0.     0. ]
 [   0.  7317.8    0.     0.     0. ]
 [   0.     0.     0.     0.  4482.6]
 [   0.     0.     0.  4482.6    0. ]], dtype=float32)

Podemos visualizar estas mediciones también nuevamente como líneas. Como pasamos puntos y conexiones entre puntos como matriz, técnicamente esto es una malla.

mean_intensity_mesh = cle.create_like(membranes)
mean_intensity_mesh = cle.touch_matrix_to_mesh(coords, mean_intensity_matrix, mean_intensity_mesh)
mean_intensity_mesh

cle._ image shape (40, 40) dtype float32 size 6.2 kB min 0.0 max 7317.8

También podemos visualizar esta malla cuantitativa sobre la imagen original de la membrana.

cle.imshow(membranes, continue_drawing=True)
cle.imshow(mean_intensity_mesh, alpha=0.5, colormap='jet', colorbar=True)

Medir la desviación estándar de la intensidad a lo largo de una línea

El mismo procedimiento también funciona para medir la desviación estándar a lo largo de las líneas.

stddev_intensity_matrix = cle.generate_standard_deviation_intensity_between_points_matrix(
                                membranes, coords, connection_matrix)
stddev_intensity_matrix

cle.array([[   0.         0.         0.         0.         0.     ]
 [   0.         0.       572.79144    0.         0.     ]
 [   0.       572.79144    0.         0.         0.     ]
 [   0.         0.         0.         0.      3758.1768 ]
 [   0.         0.         0.      3758.1772     0.     ]], dtype=float32)

stddev_intensity_mesh = cle.create_like(membranes)
stddev_intensity_mesh = cle.touch_matrix_to_mesh(coords, stddev_intensity_matrix, stddev_intensity_mesh)

cle.imshow(membranes, continue_drawing=True)
cle.imshow(stddev_intensity_mesh, alpha=0.5, colormap='jet', colorbar=True)