Transformations affines utilisant clesperanto#

Ce notebook démontre comment appliquer des transformations affines à des images 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

# Charger les données d'exemple
np_array = imread('../../data/Haase_MRT_tfl3d1.tif')
np_array.shape

(192, 256, 256)

# le pousser vers la mémoire GPU
input_image = cle.push_zyx(np_array)

cle.imshow(input_image)
../_images/281e43ff45adbeef88ee10bfd05ebeb81f145c67d81c4a8e48939ea501006835.png

Rotation#

Pour faire pivoter une image, vous devez fournir des angles correspondant aux axes.

rotated = cle.rotate(input_image, angle_around_z_in_degrees=45)
cle.imshow(rotated)
../_images/119e50d78e215eda2bc974f4a5a42d203ae3e21e1ed683d75f9678659d029c17.png

Les images sont pivotées autour de leur centre par défaut. Vous pouvez changer cela en fournissant un paramètre supplémentaire. L’image sera alors pivotée autour de l’origine.

rotated = cle.rotate(input_image, angle_around_z_in_degrees=15, rotate_around_center=False)
cle.imshow(rotated)
../_images/3791ad32a5b98b994cde602e851ce872b1d3b109313a83c8b314b24d1f41ae56.png

Translation#

Les images peuvent être translatées en fournissant des distances de translation le long des axes :

translated = cle.translate(input_image, translate_x=50, translate_y=-50)
cle.imshow(translated)
../_images/78833893e8baf0bdd071981d85eaefa4453bfe02a3c630a0538db90e5b8d28ff.png

Mise à l’échelle#

Vous pouvez mettre l’image à l’échelle en fournissant des facteurs d’échelle.

scaled = cle.scale(input_image, factor_x=0.5, factor_y=2)
cle.imshow(scaled)
../_images/c79d880c574fbf1179e783693fc82fcfc3b9591fe4702c3dc7dacacb83e9913e.png

Dans ce contexte, le paramètre auto_size peut être utile :

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

Transformation rigide#

Les transformations rigides permettent d’effectuer des translations et des rotations en une seule fois

rigid_transformed = cle.rigid_transform(input_image, translate_x=50, angle_around_z_in_degrees=45)
cle.imshow(rigid_transformed)
../_images/32cb5d2696f9ba0ce95cc0e669330529cf2f1faf97bbe0c37583a2ac57911ea1.png

Transformations affines#

Pour effectuer une translation, une rotation, une mise à l’échelle et un cisaillement en une seule fois, utilisez les transformations affines.

Pour configurer une transformation affine, vous pouvez le faire en utilisant une matrice de transformation 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)
../_images/e1b51b7631cf6154c54ca8f5e6f8390b44a694f4798c67a7765194fdd11ff93e.png

Alternativement, vous pouvez configurer un objet de transformation et le passer :

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)
../_images/e1b51b7631cf6154c54ca8f5e6f8390b44a694f4798c67a7765194fdd11ff93e.png

Cisaillement#

Fournir l’angle de cisaillement cisaillera l’image dans le plan souhaité

Le cisaillement est calculé en utilisant l’angle de cisaillement selon l’équation suivante :

1.0/ tan(shear_angle_in_degrees * pi / 180)

#Par exemple, pour cisailler l'image sur l'axe Y le long du plan YZ en utilisant un angle de cisaillement de 30 degrés

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)

##afficher les images dans chaque plan
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
../_images/4523d6990ba754f2d5ca5a32de06d4d13e711df4a453cc210d2ce93bdfe71f7d.png 
xz
../_images/00653f97f42feb8ebadff81de25ef94fb184e8285280c07ceb5a525d777a524b.png 
xy
../_images/403ea6862c2336bbc1e3f1f296c051748ee6a028973b21dfe8e1b06fa877dcff.png

Interpolation linéaire versus interpolation du plus proche voisin#

Découpons le nez et transformons-le en utilisant différents modes d’interpolation.

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

cle.imshow(crop)
../_images/3b4231a7c79b129f5c0ba17b61b4f264c8da1d448f01d1feb2e4b68e82a11aeb.png

Interpolation du plus proche voisin#

# créer une image plus grande
rescaled = cle.create(np.asarray(crop.shape) * 10)

# la remplir avec une version mise à l'échelle de l'image ; 
cle.scale(crop, rescaled, factor_x=10, factor_y=10, factor_z=10, linear_interpolation=False)
cle.imshow(rescaled)
../_images/20fb59a4995d29c6a0ebe6e2f230b94fe52c18e90a1b0eaf9ecd9782498a37d9.png

Interpolation linéaire#

# la remplir avec une version mise à l'échelle de l'image ; 
cle.scale(crop, rescaled, factor_x=10, factor_y=10, factor_z=10, linear_interpolation=True)
cle.imshow(rescaled)
../_images/5e39ac2af19022da0e0039f54d9a76e05a51b15c317bddde82001dc4cf1f86c0.png