Transformation affine avec Matplotlib

Introduction

Ce laboratoire montre comment utiliser Matplotlib pour effectuer une transformation affine d'une image. Les transformations affines modifient la forme et l'orientation d'une image. Ce laboratoire montre comment utiliser la fonction transforms.Affine2D pour manipuler la forme et l'orientation d'une image.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques et définition de l'image

Dans la première étape, nous importons les bibliothèques nécessaires et définissons l'image qui sera utilisée dans l'exemple. L'image est une combinaison de deux fonctions gaussiennes.

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.transforms as mtransforms

def get_image():
    delta = 0.25
    x = y = np.arange(-3.0, 3.0, delta)
    X, Y = np.meshgrid(x, y)
    Z1 = np.exp(-X**2 - Y**2)
    Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
    Z = (Z1 - Z2)
    return Z

Créer une fonction pour tracer l'image

Dans cette étape, nous définissons une fonction qui prend l'image, l'axe de tracé et la transformation en entrées. La fonction affiche l'image sur l'axe de tracé avec la transformation spécifiée. La fonction affiche également un rectangle jaune autour de l'image pour montrer l'étendue souhaitée de l'image.

def do_plot(ax, Z, transform):
    im = ax.imshow(Z, interpolation='none',
                   origin='lower',
                   extent=[-2, 4, -3, 2], clip_on=True)

    trans_data = transform + ax.transData
    im.set_transform(trans_data)

    ## affiche l'étendue souhaitée de l'image
    x1, x2, y1, y2 = im.get_extent()
    ax.plot([x1, x2, x2, x1, x1], [y1, y1, y2, y2, y1], "y--",
            transform=trans_data)
    ax.set_xlim(-5, 5)
    ax.set_ylim(-4, 4)

Effectuer une rotation d'image

Dans cette étape, nous effectuons une rotation de l'image à l'aide de la fonction rotate_deg. Nous passons l'angle de rotation en tant qu'entrée à la fonction rotate_deg. Nous utilisons la fonction do_plot pour afficher l'image tournée.

## préparer l'image et la figure
fig, ax1 = plt.subplots()
Z = get_image()

## rotation de l'image
do_plot(ax1, Z, mtransforms.Affine2D().rotate_deg(30))

Effectuer une distorsion d'image

Dans cette étape, nous effectuons une distorsion de l'image à l'aide de la fonction skew_deg. Nous passons les angles de distorsion en tant qu'entrées à la fonction skew_deg. Nous utilisons la fonction do_plot pour afficher l'image distordue.

## préparer l'image et la figure
fig, ax2 = plt.subplots()
Z = get_image()

## distorsion de l'image
do_plot(ax2, Z, mtransforms.Affine2D().skew_deg(30, 15))

Effectuer une mise à l'échelle et une réflexion de l'image

Dans cette étape, nous effectuons une mise à l'échelle et une réflexion de l'image à l'aide de la fonction scale. Nous passons les facteurs de mise à l'échelle et de réflexion en tant qu'entrées à la fonction scale. Nous utilisons la fonction do_plot pour afficher l'image mise à l'échelle et réfléchie.

## préparer l'image et la figure
fig, ax3 = plt.subplots()
Z = get_image()

## mise à l'échelle et réflexion
do_plot(ax3, Z, mtransforms.Affine2D().scale(-1,.5))

Effectuer plusieurs transformations

Dans cette étape, nous effectuons plusieurs transformations de l'image à l'aide des fonctions rotate_deg, skew_deg, scale et translate. Nous passons les paramètres de transformation en tant qu'entrées aux fonctions respectives. Nous utilisons la fonction do_plot pour afficher l'image transformée.

## préparer l'image et la figure
fig, ax4 = plt.subplots()
Z = get_image()

## tout et une translation
do_plot(ax4, Z, mtransforms.Affine2D().
        rotate_deg(30).skew_deg(30, 15).scale(-1,.5).translate(.5, -1))

Sommaire

Ce laboratoire a démontré comment utiliser Matplotlib pour effectuer une transformation affine d'une image. Nous avons utilisé la fonction transforms.Affine2D pour manipuler la forme et l'orientation d'une image. Nous avons effectué une rotation, une distorsion, une mise à l'échelle, une réflexion et plusieurs transformations de l'image. Nous avons également affiché l'image transformée sur un axe de tracé avec l'étendue souhaitée de l'image.