Triangle de Sierpiński (programme informatique)
Ces programmes récursifs écrits en C soit Java, permettent de générer des triangles de Sierpiński.
En C
Ce programme utilise la bibliothèque graphique Allegro.
<source lang="c">
/* pour compiler taper en ligne de commande :
gcc triangle.c -o triangle `allegro-config --libs` pour exécuter taper triangle suivi du nombre d'itérations : triangle 7 */
- include <stdlib.h>
- include <math.h>
- include "allegro.h"
- define MAXX 768
- define MAXY 665
- define OX 5
- define OY 5
- define TX 758
- define TY 655
BITMAP *bmp;
/* fonction récursive, qui a pour paramètres :
les coordonnées (x, y) de l'extrémité gauche de la base d'un triangle équilatéral, a la longueur d'un de ses cotés et n le nombre d'itérations */
void triangle_Sierpinski(double x, double y, double a, int n) {
double b=-a*sqrt(3.0)/2;
/* négatif à cause de l'orientation
de l'axe des ordonnées vers le bas */
if (n>0)
{
/* on dessine un triangle plein */
triangle(bmp, (int) x, (int) y, (int) (x+a), (int)y, (int)(x+a/2),(int)(y+b), 4);
/* et on supprime le petit triangle central */
triangle(bmp, (int) (x+a/2), (int) y, (int) (x+3*a/4), (int)(y+b/2), (int)(x+a/4),(int)(y+b/2), 0);
/* appels récursifs */
triangle_Sierpinski(x, y, a/2, n-1);
triangle_Sierpinski(x+a/2, y, a/2, n-1);
triangle_Sierpinski(x+a/4, y+b/2, a/2, n-1);
}
}
int main(int argc, char *argv[]) {
unsigned long n=1;
if (argc>1) n=strtoul(argv[1], NULL, 10);
/* initialisation de allegro */
allegro_init();
set_color_depth(8);
/* fixe la palette */
set_palette(desktop_palette);
bmp = create_bitmap(MAXX, MAXY);
if(!bmp)
{
allegro_message("Ne peut pas créer l'image\n");
return 1;
}
triangle_Sierpinski(OX, OY+TY, TX, (int)n);
save_bitmap("Triangle_de_Sierpinski.pcx", bmp, desktop_palette);
destroy_bitmap(bmp);
return 0;
}
END_OF_MAIN(); /* note finale des programmes allegro */ </source>
En Java
La méthode récursive private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) accepte des coordonnées de trois points (coins du triangle principal) plus ou moins arbitraires.
- Pour Compiler (vous devez disposez du JDK Java) :
javac SierpinskiTriangle.java - Pour exécuter :
- Avec un éditeur de texte, créez le fichier SierpinskiTriangle.html dans le même répertoire que SierpinskiTriangle.class créé lors de la compilation. Copiez-y le code html ci-dessous.
- Ouvrez le fichier SierpinskiTriangle.html avec un navigateur comme Firefox.
Source de SierpinskiTriangle.html : <source lang="xml"><!DOCTYPE html PUBLIC "-//IETF//DTD HTML 2.0//EN"> <html> <title> SierpinskiTriangle </title> <body> <applet code="SierpinskiTriangle.class" width=1024 height=1024> Java n'est pas installé ! </applet> </body> </html> </source>
Source de SierpinskiTriangle.java : <source lang="java"> /* Nom du fichier : SierpinskiTriangle.java */ import java.awt.*; import java.applet.*;
public class SierpinskiTriangle extends Applet {
private Graphics g; private int dMin=8; // limite à la récursion en pixels
public void paint(Graphics g) {
this.g = g;
int d = 1024; // base (largeur du triangle)
int x0 = 50; // distance de gauche
int y0 = 50; // distance du haut
int h = (int)(d*Math.sqrt(3)/2); // hauteur
// adapté à un triangle équilatéral
// spécification du triangle principal: points A, B, C
int xA=x0, yA=y0+h; // (bas-gauche)
int xB=x0+d, yB=y0+h; // (bas-droite)
// int xB=x0, yB=y0; // (haut-gauche)
// int xB=x0+d, yB=y0; // (haut-droite)
int xC=x0+d/2, yC=y0; // triangle équilatéral (haut-milieu)
// int xC=x0, yC=y0; // (haut-gauche)
// triangle perpendiculaire, angle droit près A
// int xC=x0+d, yC=y0; // (haut-droite)
// triangle perpendiculaire, angle droit près B
int[] x = { xA, xB, xC };
int[] y = { yA, yB, yC };
drawSierpinskiTriangle( x, y, d/2 ); // démarrer la récursion }
private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) {
if (d<dMin) g.fillPolygon ( x, y, 3 ); // fond de la récursion
else {
// milieus des cotés du triangle:
int xMc = (x[0]+x[1])/2, yMc = (y[0]+y[1])/2;
int xMb = (x[0]+x[2])/2, yMb = (y[0]+y[2])/2;
int xMa = (x[1]+x[2])/2, yMa = (y[1]+y[2])/2;
int[] xNouveau1 = { x[0], xMc, xMb };
int[] yNouveau1 = { y[0], yMc, yMb };
drawSierpinskiTriangle ( xNouveau1, yNouveau1, d/2 ); // récursion
int[] xNouveau2 = { x[1], xMc, xMa };
int[] yNouveau2 = { y[1], yMc, yMa };
drawSierpinskiTriangle ( xNouveau2, yNouveau2, d/2 ); // récursion
int[] xNouveau3 = { x[2], xMb, xMa };
int[] yNouveau3 = { y[2], yMb, yMa };
drawSierpinskiTriangle ( xNouveau3, yNouveau3, d/2 ); // récursion
}
}
} </source>
Article publié sur Wikimonde Plus
