Triangle de Sierpiński

Ces programmes récursifs écrits en C et en Java, permettent de générer des triangles de Sierpiński.

En C

Ce programme utilise la bibliothèque graphique Allegro.

/* 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 côté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 */

En Java

Le programme ci-dessous dessine un triangle de Sierpiński dans une fenêtre en utilisant la bibliothèque Swing pour l'interface utilisateur.

La méthode récursive private void drawSierpinskiTriangle(Graphics g, 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

Source de SierpinskiTriangle.java :

/* Nom du fichier : SierpinskiTriangle.java */
package org.wikibooks.fr.swing;

import java.awt.*;

import javax.swing.*;

/**
 * Triangle de Sierpiński
 * @author fr.wikibooks.org
 */
public class SierpinskiTriangle extends JComponent
{
	private final int size;
	private final int d_min = 8;

	public SierpinskiTriangle(int size)
	{
		this.size = size;
		Dimension d = new Dimension(size, size);
		setPreferredSize(d);
		setMinimumSize(d);
	}

	@Override
	protected void paintComponent(Graphics g)
	{
		g.setColor(getBackground());
		g.clearRect(0, 0, size, size);
		g.setColor(getForeground());

		int x0 = 0; // distance de gauche
		int y0 = 0; // distance du haut
		int h = (int) (size * 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 + size, yB = y0 + h; // (bas-droite)
		// int xB=x0, yB=y0; // (haut-gauche)
		// int xB=x0+d, yB=y0; // (haut-droite)
		int xC = x0 + size / 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(g, x, y, size / 2); // démarrer la récursion
	}

	private void drawSierpinskiTriangle(Graphics g, int[] x, int[] y, int d)
	{
		if (d < d_min)
			g.fillPolygon(x, y, 3); // fin de la récursion
		else
		{
			// milieux des côté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(g, xNouveau1, yNouveau1, d / 2); // récursion

			int[] xNouveau2 =
				{ x[1], xMc, xMa };
			int[] yNouveau2 =
				{ y[1], yMc, yMa };
			drawSierpinskiTriangle(g, xNouveau2, yNouveau2, d / 2); // récursion

			int[] xNouveau3 =
				{ x[2], xMb, xMa };
			int[] yNouveau3 =
				{ y[2], yMb, yMa };
			drawSierpinskiTriangle(g, xNouveau3, yNouveau3, d / 2); // récursion
		}
	}

	public static void main(String[] args)
	{
		JFrame f = new JFrame("Triangle de Sierpiński");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(new SierpinskiTriangle(1024));
		f.pack();
		f.setVisible(true);
	}
}