Statistiques descriptives de [nombreuses] lignes dans une image

Lors de l’étude de l’intensité le long de nombreuses lignes dans une image, cela peut être fait en parallèle sur un GPU. Ce notebook démontre cela en utilisant seulement deux lignes à des fins d’illustration. On peut supposer que la lecture en parallèle de centaines ou de milliers de lignes a du sens en termes de performance sur les GPU.

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

Pour démontrer un cas d’utilisation potentiel, nous examinons de près une image de cellules exprimant un marqueur membranaire.

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

Nous définissons les coordonnées de quatre points qui seront reliés pour former deux lignes. La connexion sera effectuée à l’aide d’une matrice de contact qui permet de connecter n points avec n points.

coords = np.asarray([
    [0, 17],  # ligne 1 début (x, y)
    [10, 24], # ligne 1 fin
    [20, 21], # ligne 2
    [35, 21]
]).T

connection_matrix = cle.symmetric_maximum_matrix(np.asarray([
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0], # ceci connecte les deux points de la ligne 1
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 1], # ceci connecte les deux points de la ligne 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)

Tout d’abord, nous visualisons ces lignes sur l’image de la membrane.

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')

Mesurer l’intensité moyenne le long des lignes

Ensuite, nous utilisons la matrice configurée ci-dessus pour mesurer l’intensité moyenne le long des lignes. Nous devons également spécifier combien d’échantillons seront prélevés le long des lignes.

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)

Nous pouvons également visualiser ces mesures sous forme de lignes. Comme nous passons des points et des connexions entre points sous forme de matrice, il s’agit techniquement d’un maillage.

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

Nous pouvons également visualiser ce maillage quantitatif sur l’image originale de la membrane.

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

Mesurer l’écart-type de l’intensité le long d’une ligne

La même procédure fonctionne également pour mesurer l’écart-type le long des lignes.

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)