Transformaciones afines usando clesperanto

Este notebook demuestra cómo aplicar transformaciones afines a imágenes 3D.

import pyclesperanto_prototype as cle

cle.select_device('TX')

<NVIDIA GeForce GTX 1650 with Max-Q Design on Platform: NVIDIA CUDA (1 refs)>

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from skimage.io import imread

# Cargar datos de ejemplo
np_array = imread('../../data/Haase_MRT_tfl3d1.tif')
np_array.shape

(192, 256, 256)

# enviar a la memoria de la GPU
input_image = cle.push_zyx(np_array)

cle.imshow(input_image)

Rotación

Para rotar una imagen, necesitas proporcionar ángulos correspondientes a los ejes.

rotated = cle.rotate(input_image, angle_around_z_in_degrees=45)
cle.imshow(rotated)

Las imágenes se rotan alrededor de su centro por defecto. Puedes cambiar esto proporcionando un parámetro adicional. La imagen se rotará entonces alrededor del origen.

rotated = cle.rotate(input_image, angle_around_z_in_degrees=15, rotate_around_center=False)
cle.imshow(rotated)

Traslación

Las imágenes se pueden trasladar proporcionando distancias de traslación a lo largo de los ejes:

translated = cle.translate(input_image, translate_x=50, translate_y=-50)
cle.imshow(translated)

Escalado

Puedes escalar la imagen proporcionando factores de escala.

scaled = cle.scale(input_image, factor_x=0.5, factor_y=2)
cle.imshow(scaled)

En este contexto, el parámetro auto_size puede ser útil:

scaled_auto_size = cle.scale(input_image, factor_x=0.5, factor_y=2, auto_size=True)
cle.imshow(scaled_auto_size)

Transformación rígida

Las transformaciones rígidas permiten realizar traslaciones y rotaciones de una sola vez

rigid_transformed = cle.rigid_transform(input_image, translate_x=50, angle_around_z_in_degrees=45)
cle.imshow(rigid_transformed)

Transformaciones afines

Para realizar traslación, rotación, escalado y cizallamiento de una sola vez, utiliza transformaciones afines.

Para configurar una transformación afín, puedes hacerlo utilizando una matriz de transformación 4x4:

transform_matrix = np.asarray([
    [1, 0, 0, 50],
    [0, 2, 0, 0],
    [0, 0, 0.5, 0],
    [0, 0, 0, 1]
])
transformed_image = cle.affine_transform(input_image, transform=transform_matrix)
cle.imshow(transformed_image)

Alternativamente, puedes configurar un objeto de transformación y pasarlo:

transform = cle.AffineTransform3D()
transform.translate(50)
transform.scale(1, 2, 0.5)

transformed_image = cle.affine_transform(input_image, transform=transform)
cle.imshow(transformed_image)

Cizallamiento

Proporcionar el ángulo de cizallamiento cizallará la imagen en el plano deseado

El cizallamiento se calcula utilizando el ángulo de cizallamiento mediante la siguiente ecuación:

1.0/ tan(shear_angle_in_degrees * pi / 180)

#Por ejemplo, para cizallar la imagen en el eje Y a lo largo del plano YZ usando un ángulo de cizallamiento de 30 grados

shear_angle = 30.0

transform = cle.AffineTransform3D()
shear_transform= transform.shear_in_z_plane(angle_y_in_degrees=shear_angle)

transformed_image = cle.affine_transform(input_image, transform=shear_transform)

##mostrar imágenes en cada plano
print("yz")
cle.imshow(cle.maximum_x_projection(transformed_image))
print("xz")
cle.imshow(cle.maximum_y_projection(transformed_image))
print("xy")
cle.imshow(cle.maximum_z_projection(transformed_image))

yz

xz

xy

Interpolación lineal versus interpolación del vecino más cercano

Vamos a recortar la nariz y transformarla usando diferentes modos de interpolación.

crop = input_image[50,125:150,45:70]

cle.imshow(crop)

Interpolación del vecino más cercano

# crear una imagen más grande
rescaled = cle.create(np.asarray(crop.shape) * 10)

# llenarla con una versión escalada de la imagen; 
cle.scale(crop, rescaled, factor_x=10, factor_y=10, factor_z=10, linear_interpolation=False)
cle.imshow(rescaled)

Interpolación lineal

# llenarla con una versión escalada de la imagen; 
cle.scale(crop, rescaled, factor_x=10, factor_y=10, factor_z=10, linear_interpolation=True)
cle.imshow(rescaled)