Compte rendu de TP d’informatique
Projet : Représentation de la fougère de Barnsley
Binôme :
Mehdi Boudane
Houssam Hanane
Année universitaire : 2025–2026
ENSEIRB-MATMECA
1 Introduction
L’objectif de ce TP est de représenter informatiquement une fougère de Barnsley en langage C. Le
travail demandé consiste surtout à expliquer la démarche suivie pendant l’écriture du code, ainsi que
la stratégie utilisée pour construire la figure.
La méthode repose sur une construction géométrique : on part d’un hexagone d’approximation,
puis on génère plusieurs sous-figures à partir de données d’héritage. Enfin, une récursivité permet de
répéter ce procédé sur plusieurs niveaux afin d’obtenir une forme proche d’une fougère.
2 Préparation de l’image
Le programme commence par créer une image blanche de taille 1600 × 900 pixels. Chaque pixel est
représenté par trois composantes RGB : rouge, vert et bleu.
La fonction image_blanc() initialise tous les pixels en blanc :
R = 255, G = 255, B = 255
Ensuite, la fonction set_pixel() permet de colorier un pixel donné. Elle vérifie que les coordonnées
appartiennent bien à l’image :
0 ≤ x < hauteur, 0 ≤ y < largeur
Cette vérification est nécessaire pour éviter les erreurs mémoire lorsque les calculs donnent des
points en dehors de l’image.
3 Tracé des segments
La fonction draw_line() permet de tracer un segment entre deux points (x1 , y1 ) et (x2 , y2 ). Elle
calcule plusieurs points intermédiaires entre les deux extrémités puis colore les pixels correspondants.
Cette fonction est essentielle, car toute la fougère est construite à partir de segments reliant les
sommets des hexagones.
4 Construction de l’hexagone de base
La première vraie étape géométrique consiste à construire un hexagone d’approximation de la
fougère. Les données utilisées sont les longueurs et les angles fournis dans l’énoncé.
Les longueurs sont stockées dans le tableau :
L = {0.335, 0.877, 1.086, 0.765, 0.339}
Les angles sont stockés dans le tableau :
A = {0.9421, −0.0647, −0.3, −0.263, −1.175}
La fonction dessiner_hexagone() calcule les sommets de l’hexagone à partir du point d’origine
O, de l’angle de base et de la taille de la figure.
Les coordonnées sont calculées par :
x = xO − Li · taille · sin(θ)
y = yO + Li · taille · cos(θ)
avec :
1
θ = angle_base + Ai
Une fois les sommets calculés, ils sont reliés avec la fonction draw_line().
5 Création des sous-figures
Après avoir obtenu l’hexagone de base, on construit trois sous-hexagones. Ces sous-figures sont
définies à partir des données d’héritage de l’énoncé.
Dans le code, on utilise trois tableaux :
pos = {0.16, 0.12, 0.08}
π π
ang = {−0.05, , − }
2 2
tailles = {0.86, 0.27, 0.30}
Le tableau pos donne la position de chaque sous-figure par rapport à la figure mère. Le tableau
ang donne son orientation, et tailles donne son facteur de réduction.
Pour chaque sous-figure, on calcule donc une nouvelle origine, un nouvel angle et une nouvelle
taille :
taillenouvelle = taillemre × coef f icient
6 Correction par effet miroir
Lors des premiers essais, la figure obtenue était presque correcte, mais le troisième hexagone n’était
pas orienté dans le bon sens. Pour corriger ce problème, on a ajouté une variable miroir.
Lorsque miroir = 0, les angles sont utilisés normalement :
θ = angle_base + Ai
Lorsque miroir = 1, les angles sont inversés :
θ = angle_base − Ai
L’effet miroir est appliqué uniquement à la troisième sous-figure, c’est-à-dire lorsque l’indice vaut
k = 2. Cela permet de retrouver l’orientation correcte de la fougère.
7 Utilisation de la récursivité
La fonction recurrence_hexagone() permet de répéter la construction sur plusieurs niveaux.
À chaque appel récursif, le programme calcule les trois sous-figures associées à la figure actuelle,
puis rappelle la même fonction pour chacune d’elles avec une taille plus petite et un niveau diminué.
La récursivité s’arrête lorsque :
niveau = 0
Cela évite une boucle infinie et permet de contrôler la précision de la figure.
2
8 Amélioration du résultat
Lors des premiers tests avec plusieurs niveaux, des traits non souhaités apparaissaient sur les
premiers niveaux. Pour améliorer le rendu, on a ajouté une condition sur la taille de la figure :
taille < 15
Ainsi, certains tracés ne sont effectués que lorsque la figure devient suffisamment petite. Cela permet
d’obtenir une fougère plus propre visuellement.
9 Enregistrement de l’image
Une fois la figure construite, l’image est enregistrée au format PPM avec la fonction save_image().
Le fichier généré est :
[Link]
Ce format est simple à utiliser en langage C, car il permet d’écrire directement les valeurs RGB
des pixels.
10 Conclusion
Ce TP nous a permis de comprendre comment générer une figure fractale à partir de règles géo-
métriques simples. La construction commence par un hexagone de base, puis se poursuit avec trois
sous-figures obtenues par changement d’échelle, rotation et effet miroir.
La récursivité est l’élément principal du programme : elle permet de répéter la même construction
à différentes tailles et d’obtenir progressivement une fougère complète.