Visualisation de données Python avec Matplotlib | Tutoriel sur les canaux RGB

Introduction

Matplotlib est une bibliothèque populaire de visualisation de données en Python. Elle fournit divers outils de tracé, y compris des capacités de tracé 2D et 3D. Dans ce tutoriel, nous utiliserons le module RGBAxes du toolkit AxesGrid dans Matplotlib pour afficher les canaux RGB.

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 Notebook pour accéder à Jupyter Notebook pour la pratique.

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

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.

Importez les bibliothèques nécessaires

Dans cette étape, nous allons importer les bibliothèques nécessaires : numpy, matplotlib.pyplot et mpl_toolkits.axes_grid1.axes_rgb.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes, make_rgb_axes

Définissez une fonction pour obtenir les canaux RGB

Dans cette étape, nous allons définir une fonction get_rgb() pour obtenir les canaux R, G et B d'une image. Dans cet exemple, nous utiliserons la fonction get_sample_data() du module cbook pour obtenir une image d'échantillonnage.

import matplotlib.cbook as cbook

def get_rgb():
    ## Obtenez une image d'échantillonnage
    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
    Z[Z < 0] = 0.
    Z = Z / Z.max()

    ## Obtenez les canaux R, G et B
    R = Z[:13, :13]
    G = Z[2:, 2:]
    B = Z[:13, 2:]

    return R, G, B

Définissez une fonction pour créer un cube RGB

Dans cette étape, nous allons définir une fonction make_cube() pour créer un cube RGB à partir des canaux R, G et B obtenus dans l'étape précédente. La fonction retournera les cubes R, G et B, ainsi que l'image RGB.

def make_cube(r, g, b):
    ## Obtenez la forme de R
    ny, nx = r.shape

    ## Créez les cubes R, G et B
    R = np.zeros((ny, nx, 3))
    R[:, :, 0] = r
    G = np.zeros_like(R)
    G[:, :, 1] = g
    B = np.zeros_like(R)
    B[:, :, 2] = b

    ## Combinez les cubes R, G et B pour créer l'image RGB
    RGB = R + G + B

    return R, G, B, RGB

Créez un tracé RGBAxes

Dans cette étape, nous allons créer un tracé RGBAxes en utilisant la classe RGBAxes. Nous utiliserons la méthode imshow_rgb() de l'objet RGBAxes pour afficher l'image RGB.

def demo_rgb1():
    ## Créez une figure et un objet RGBAxes
    fig = plt.figure()
    ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0)

    ## Obtenez les canaux R, G et B
    r, g, b = get_rgb()

    ## Affichez l'image RGB à l'aide de la méthode imshow_rgb()
    ax.imshow_rgb(r, g, b)

Créez un tracé RGBAxes avec des canaux séparés

Dans cette étape, nous allons créer un tracé RGBAxes avec des canaux séparés en utilisant la fonction make_rgb_axes(). Nous utiliserons la méthode imshow() des objets Axes pour afficher les canaux R, G et B.

def demo_rgb2():
    ## Créez une figure et un objet Axes
    fig, ax = plt.subplots()

    ## Créez les objets Axes R, G et B à l'aide de la fonction make_rgb_axes()
    ax_r, ax_g, ax_b = make_rgb_axes(ax, pad=0.02)

    ## Obtenez les canaux R, G et B et créez le cube RGB
    r, g, b = get_rgb()
    im_r, im_g, im_b, im_rgb = make_cube(r, g, b)

    ## Affichez l'image RGB et les canaux R, G et B
    ax.imshow(im_rgb)
    ax_r.imshow(im_r)
    ax_g.imshow(im_g)
    ax_b.imshow(im_b)

    ## Réglez les paramètres d'échelle et les couleurs des bords pour tous les objets Axes
    for ax in fig.axes:
        ax.tick_params(direction='in', color='w')
        ax.spines[:].set_color("w")

Affichez les tracés

Dans cette étape, nous appellerons les fonctions demo_rgb1() et demo_rgb2() pour créer les tracés et les afficher à l'aide de la fonction plt.show().

demo_rgb1()
demo_rgb2()

plt.show()

Sommaire

Dans ce tutoriel, nous avons appris à utiliser le module RGBAxes du toolkit AxesGrid dans Matplotlib pour afficher les canaux RGB. Nous avons couvert les étapes suivantes :

Importer les bibliothèques nécessaires
Définir une fonction pour obtenir les canaux RGB
Définir une fonction pour créer un cube RGB
Créer un tracé RGBAxes
Créer un tracé RGBAxes avec des canaux séparés
Afficher les tracés.

Visualisation des canaux RGB avec Matplotlib