Bonjour,

voilà une petite classe qui effectue la construction du flocon de Von Koch.
Sans doute la fractale la plus connue qui lorsque le nombre d'itération tend vers l'infinie, a un périmètre infini mais une aire finie.


Code java : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
import java.util.List;
import java.util.Vector;
 
import mathematiques.primitives.pointstiti.Point;
import mathematiques.primitives.pointstiti.Point3DF;
import mathematiques.primitives.pointstiti.PointI;
 
/**
 * <p>Description : Cette classe effectue le calcul du flocon de Von Koch pour un nombre d'itérations donnees.</p>
 * <p>Package necessaires : affichage, mathematiques.</p>
 * <p>Dernieres modifications :<br>
 * 23 Avril 2009 => Un petit lifting pour effacer les erreurs de jeunesse.<br>
 * Durant mes debuts en Java => Creation.</p>
 * <p>Copyright : Copyright (c) 2007.</p>
 * <p>Laboratoire : LSIS.</p>
 * <p>Equipe : Image et Modele, I&M (ex LXAO).</p>
 * 
 * @author Guillaume THIBAULT
 * @version 1.0
 */
 
public class VonKoch implements Affichable
{
 
/** Est ce que le calcul a deja ete fait ?*/
protected boolean Effectue = false ;
/** La liste des points formant le flocon.*/
protected List<Point> Liste = new Vector<Point>() ;
 
 
public VonKoch()
	{
	}
 
 
/** Methode qui lance le calcul.
 * @param ListeIn La liste des trois premiers points. Le sens des points determine la forme du flocon.
 * @param nbIterations Le nombre d'iteration a effectuer.*/
public void Compute(List<Point> ListeIn, int nbIterations)
	{
	int i ;
	if ( Effectue ) return ;
	for (i=0 ; i < ListeIn.size() ; i++)
		Liste.add(new Point3DF(ListeIn.get(i))) ;
	Calculs(nbIterations) ;
	}
 
 
/** Methode qui lance le calcul a partir d'une liste contenant des points en coordonnees entieres.
 * @param ListeIn La liste des trois premiers points. Le sens des points determine la forme du flocon.
 * @param nbIterations Le nombre d'iteration a effectuer.*/
public void ComputeI(List<PointI> ListeIn, int nbIterations)
	{
	if ( Effectue ) return ;
 
	for (int i=0 ; i < ListeIn.size() ; i++)
		Liste.add(new Point3DF(ListeIn.get(i).getX(), ListeIn.get(i).getY())) ;
 
	Calculs(nbIterations) ;
	}
 
 
/** Methode qui effectue les calculs.
 * @param nbIterations Le nombre d'iteration a effectuer.*/
protected void Calculs(int nbIterations)
	{
	int i, n ;
	Point p1, p2, p3 ;
	Point Inter = new Point3DF() ;
 
	for (n=0 ; n < nbIterations ; n++)
		for (i=0 ; i < Liste.size()-1 ; )
			{
			p1 = new Point3DF() ;
			p2 = new Point3DF() ;
			p3 = new Point3DF() ;
 
			p1.setX( Liste.get(i).getX() + (Liste.get(i+1).getX()-Liste.get(i).getX()) / 3.0 ) ;
			p1.setY( Liste.get(i).getY() + (Liste.get(i+1).getY()-Liste.get(i).getY()) / 3.0 ) ;
			p3.setX( Liste.get(i).getX() + 2.0*(Liste.get(i+1).getX()-Liste.get(i).getX()) / 3.0 ) ;
			p3.setY( Liste.get(i).getY() + 2.0*(Liste.get(i+1).getY()-Liste.get(i).getY()) / 3.0 ) ;
			Inter.setX(p3.getX()-p1.getX()) ;
			Inter.setY(p3.getY()-p1.getY()) ;
			p2.setX(Inter.getX()*Math.cos(Math.PI/3.0) + Inter.getY()*Math.sin(Math.PI/3.0)) ;
			p2.setY(-Inter.getX()*Math.sin(Math.PI/3.0) + Inter.getY()*Math.cos(Math.PI/3.0)) ;
			p2.setX(p1.getX()+p2.getX()) ;
			p2.setY(p1.getY()+p2.getY()) ;
 
			Liste.add(i+1, p1) ;
			Liste.add(i+2, p2) ;
			Liste.add(i+3, p3) ;
			i += 4 ;
			}
 
	Effectue = true ;
	}
 
 
 
 
 
 
 
 
 
 
/* ----------------------------------------------------- Les getters & autres ----------------------------------------------------- */
/** Methode qui retourne la liste des points formant le flocon.
 * @return Une List contenant les points.*/
public List<Point> getListe()
	{
	return Liste ;
	}
 
/** Methode qui vide la liste.*/
public void Reset()
	{
	Liste.clear() ;
	Effectue = false ;
	}
 
}


Un petit exemple d'utilisation :
Code java : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
	List<Point> liste = new Vector<Point>() ;
	liste.add(new Point3DF(600,200)) ;
	liste.add(new Point3DF(100,200)) ;
	VonKoch vk5 = new VonKoch() ;
	vk5.Compute(liste, 5) ;