Créer un polygone rempli avec Matplotlib

Introduction

Dans ce laboratoire, nous allons apprendre à créer un polygone rempli à l'aide de Matplotlib en Python. Nous utiliserons le flocon de Koch comme exemple de polygone.

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églerons rapidement le problème pour vous.

Importation des bibliothèques

Avant de commencer, importons les bibliothèques nécessaires.

import matplotlib.pyplot as plt
import numpy as np

Définir la fonction du flocon de Koch

Ensuite, nous allons définir une fonction pour générer le flocon de Koch. La fonction prend deux paramètres : la profondeur de récursion et le facteur d'échelle.

def koch_snowflake(order, scale=10):
    """
    Retourne deux listes x, y des coordonnées des points du flocon de Koch.

    Paramètres
    ----------
    order : int
        La profondeur de récursion.
    scale : float
        L'étendue du flocon (longueur du côté du triangle de base).
    """
    def _koch_snowflake_complex(order):
        if order == 0:
            ## triangle initial
            angles = np.array([0, 120, 240]) + 90
            return scale / np.sqrt(3) * np.exp(np.deg2rad(angles) * 1j)
        else:
            ZR = 0.5 - 0.5j * np.sqrt(3) / 3

            p1 = _koch_snowflake_complex(order - 1)  ## points de départ
            p2 = np.roll(p1, shift=-1)  ## points d'arrivée
            dp = p2 - p1  ## vecteurs de connexion

            new_points = np.empty(len(p1) * 4, dtype=np.complex128)
            new_points[::4] = p1
            new_points[1::4] = p1 + dp / 3
            new_points[2::4] = p1 + dp * ZR
            new_points[3::4] = p1 + dp / 3 * 2
            return new_points

    points = _koch_snowflake_complex(order)
    x, y = points.real, points.imag
    return x, y

Générer un polygone rempli

Maintenant, nous pouvons générer un polygone rempli à l'aide de la fonction fill(). Nous allons utiliser la fonction du flocon de Koch pour générer les coordonnées du polygone.

x, y = koch_snowflake(order=5)

plt.figure(figsize=(8, 8))
plt.axis('equal')
plt.fill(x, y)
plt.show()

Personnaliser le polygone

Nous pouvons personnaliser les couleurs et la largeur de ligne du polygone en utilisant des arguments clés dans la fonction fill().

x, y = koch_snowflake(order=2)

fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(9, 3),
                                    subplot_kw={'aspect': 'equal'})
ax1.fill(x, y)
ax2.fill(x, y, facecolor='lightsalmon', edgecolor='orangered', linewidth=3)
ax3.fill(x, y, facecolor='none', edgecolor='purple', linewidth=3)

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à créer un polygone rempli à l'aide de Matplotlib en Python. Nous avons utilisé le flocon de Koch comme exemple de polygone et montré comment personnaliser le polygone avec différentes couleurs et largeurs de ligne.