Construction d'une fougère (matrices)

[ProgScilab]

Bonjour,
je fais appel à vous car je suis bloqué:

Voici mon énoncé:
On s'intéresse aux transformations affines du plan, c'est à dire aux fonctions f qui transforme chaque point du plan M(x,y) en un unique point M(x',y') de la manière suivante:
f: M(x,y) --> M'(x',y') où x'=ax+by+u et y'=cx+dy+v avec a,b,c,d,u,v réels.
On notera alors: (x',y') = [a,b;c,d][x;y]+[u;v] ou encore X'=AX+U

Je dois donc faire un programme qui construit une fougère, cela grâce à 4 transformations.
F1 telle que A=[0,0;0,0.16] et U= [0;0]
F2 telle que A=[0.85,0.04;-0.04,0.85] et U= [0;1.6]
F3 telle que A=[0.2,-0.26; 0.23,0.22] et U= [0;1.6]
F4 telle que A=[-0.15,0.28;0.26,0.24] et U= [0;0.44]

On suppose qu'un point a: 1% de chance d'être transformé par F1, 85% de chance d'être transformé par F2, 7% de chance d'être transformé par F3 et également 7% de chance d'être transformé par F4.

En respectant les probabilités précédentes, je dois proposer un algorithme qui permettrait de simuler la construction d'une fougère.

J'ai décidé de faire mon algorithme dans Scilab, voici le début:

X=input("X:")
Y=input("Y:")
N=input("Nombres de boucles:")

A=[0,0;0,0.16]
B=[0;0]
C=[0.85,0.04;-0.04,0.85]
D=[0;1.6]
E=[0.2,-0.26;0.23,0.22]
F=[0;1.6]
G=[-0.15,0.28;0.26,0.24]
H=[0;0.44]
I=[X;Y]
a=I(1,1)
b=I(2,1)
plot2d(a,b,style=-1)

while N>0
R=round(rand(1)*100)
if R>0 & R<=1 then
I=A*I+B
x=I(1,1)
y=I(2,1)
plot2d(x,y,style=-1)
N=N-1
end

if R>1 & R<=86 then
I=C*I+D
x=I(1,1)
y=I(2,1)
plot2d(x,y,style=-1)
N=N-1
end

if R>86 & R<=93 then
I=E*I+F
x=I(1,1)
y=I(2,1)
plot2d(x,y,style=-1)
N=N-1
end

if R>93 & R<=100 then
I=G*I+H
x=I(1,1)
y=I(2,1)
plot2d(x,y,style=-1)
N=N-1
end

end

Mais là je bloque, comment est ce que je peux faire afin de continuer la construction de ma fougère en sachant qu'une fougère est une fractale et que c'est donc le même algorithme qui doit se reproduire à chaque fois...

Merci d'avance!
-----

[Coban]

Bonjour,
Je ne vois pas où est ton problème, ton algorithme à l'air de marcher non? Il trace la fougère pixel par pixel à chaque itération de ta boucle While non?
J'ai déjà fait ça en python peut être que ça peut t'aider:

import numpy as np
from os import system
from matplotlib import pyplot as plt
from random import randint

Dim=int(input("Dimension: "))
NbPoints=int(input("Points: "))


# les 4 fonctions:
def f1(P):
	P[1]=0
	P[0]=0.16*P[0]
	return(P)

def f2(P):
	P[1]=0.85*P[1]+0.04*P[0]
	P[0]=-0.04*P[1]+0.85*P[0]+1.6
	return(P)

def f3(P):
	P[1]=0.2*P[1]-0.26*P[0]
	P[0]=0.23*P[1]+0.22*P[0]+1.6
	return(P)

def f4(P):
	P[1]=-0.15*P[1]+0.28*P[0]
	P[0]=0.26*P[1]+0.24*P[0]+0.44
	return(P)

# matrice vide (pleine de 0)
Matrice=np.zeros((Dim, Dim), dtype="i")

# point de depart
A=[1, 3]

for a in range(NbPoints):

	# un nombre aleatoire
	alea=randint(1, 100)

	# on choisi une des 4 fonctions
	if alea == 1:
		f=f1
	if alea > 1 and alea <= 86:
		f=f2
	if alea > 86 and alea <= 93:
		f=f3
	if alea > 93:
		f=f4

	# on l'aplique au point
	A=f(A)

	# on trace le point
	Matrice[int(round(A[1]*(Dim/10)+Dim/2)), int(round(A[0]*(Dim/10)))]=1

# tout ca s'est pour l'affichage
Matrice=Matrice.transpose()
Matrice2=np.zeros((Dim, Dim), dtype="i")
for y in range(Dim):
	for x in range(Dim):
		Matrice2[Dim-1-x, Dim-1-y]=Matrice[y,x]
Matrice2=Matrice2.transpose()
Image=plt.matshow(Matrice2)
plt.show()
print("Termine")
input()

[ProgScilab]

Bonjour Coban,
Effectivement il n'y avait pas de problème dans mon programme et je m'en suis rendu compte juste après avoir posté sur le forum.
Merci

[luna211]

Bjr jai le mm algo en langage casio mais je ne comprend aps une ligne qui dit Plot Mat P[1,1],Mat P [2,1] je suppose que c ton a [1,1] et b[2,1] peut tu m expliquer a quoi correspond le a et b et d ou viennent les coordonneee stp ^^ merci

[A voir en vidéo sur Futura]