Escalado#
El escalado de imágenes es una forma inteligente de preprocesar datos de imágenes, idealmente después de la eliminación de ruido y fondo. Permite reducir el tamaño de la imagen a un grado en que aún se puede responder la pregunta científica, a la vez que se manejan las limitaciones de memoria. Por ejemplo, en caso de que la computadora se queje de errores de falta de memoria, escalar una imagen a un tamaño más pequeño es el primer método al que recurrir para continuar con un proyecto. Además, hay muchos algoritmos de segmentación y métodos de medición cuantitativa que tienen como precondición la isotropía de píxeles/vóxeles: Los vóxeles deben tener el mismo tamaño en todas las direcciones, de lo contrario los resultados de dichos algoritmos podrían ser engañosos o incluso erróneos.
import pyclesperanto_prototype as cle
import matplotlib.pyplot as plt
from skimage.io import imread
Para demostrar el escalado, estamos usando datos de imágenes recortados y remuestreados del Broad Bio Image Challenge: Ljosa V, Sokolnicki KL, Carpenter AE (2012). Annotated high-throughput microscopy image sets for validation. Nature Methods 9(7):637 / doi. PMID: 22743765 PMCID: PMC3627348. Disponible en http://dx.doi.org/10.1038/nmeth.2083
input_image = imread("../../data/BMP4blastocystC3-cropped_resampled_8bit.tif")
# el tamaño del vóxel no es igual en todas las direcciones;
# los vóxeles son anisotrópicos.
voxel_size_x = 0.202
voxel_size_y = 0.202
voxel_size_z = 1
Al visualizar proyecciones de ese conjunto de datos a lo largo de los tres ejes, se puede ver que los vóxeles no son isotrópicos.
def show(image_to_show, labels=False):
"""
Esta función genera tres proyecciones: en dirección X, Y y Z y las muestra.
"""
projection_x = cle.maximum_x_projection(image_to_show)
projection_y = cle.maximum_y_projection(image_to_show)
projection_z = cle.maximum_z_projection(image_to_show)
fig, axs = plt.subplots(1, 3, figsize=(10, 10))
cle.imshow(projection_x, plot=axs[0], labels=labels)
cle.imshow(projection_y, plot=axs[1], labels=labels)
cle.imshow(projection_z, plot=axs[2], labels=labels)
axs[0].set_title("Plano ZY")
axs[1].set_title("Plano XZ")
axs[2].set_title("Plano XY")
plt.show()
show(input_image)
Escalado con el tamaño del vóxel#
La forma más fácil de solucionar este problema es escalar el conjunto de datos con su tamaño de vóxel. Por definición, esto resultará en un conjunto de datos donde los vóxeles son isotrópicos y tienen voxel_size = 1 (micrones en nuestro caso) en todas las direcciones.
scale_factor_x = voxel_size_x
scale_factor_y = voxel_size_y
scale_factor_z = voxel_size_z
resampled = cle.scale(input_image,
factor_x=scale_factor_x,
factor_y=scale_factor_y,
factor_z=scale_factor_z,
linear_interpolation=True,
auto_size=True)
show(resampled)
La pila remuestreada ahora tiene menos vóxeles en X e Y, lo que podría ser un problema cuando se trata de segmentar los objetos con precisión. Podemos ver esto claramente imprimiendo la forma de los datos originales y la imagen remuestreada. Este es el tamaño de la pila de imágenes en profundidad-altura-ancho (Z-Y-X).
input_image.shape
(86, 396, 393)
resampled.shape
(86, 80, 79)
Una posible solución es introducir un zoom_factor. Permite ajustar cuán grande será la imagen remuestreada:
zoom_factor = 2
scale_factor_x = voxel_size_x * zoom_factor
scale_factor_y = voxel_size_y * zoom_factor
scale_factor_z = voxel_size_z * zoom_factor
resampled_zoomed = cle.scale(input_image,
factor_x=scale_factor_x,
factor_y=scale_factor_y,
factor_z=scale_factor_z,
linear_interpolation=True,
auto_size=True)
show(resampled_zoomed)
resampled_zoomed.shape
(172, 160, 159)
Al hacer zoom/escalar imágenes 3D, tenga en cuenta las limitaciones de memoria. Puede leer el tamaño de las imágenes en el cuadro de la derecha en la siguiente vista. Hacer zoom a una imagen por un factor de 2, como en el ejemplo anterior, aumenta el tamaño de la imagen de una pila 3D por un factor de 8 (2x2x2).
resampled
|
cle._ image
|
resampled_zoomed
|
cle._ image
|
Ejercicio#
Aumente el factor de zoom y vuelva a ejecutar el código anterior. ¿Con qué factor de zoom se bloquea el programa? ¿Qué tan grande sería la imagen que se generaría si no se bloqueara? ¿Cuánta memoria tiene su tarjeta gráfica?