 |
Les images que vous allez voir et dessiner sont des fractales.
A chaque image est associé un nom et des paramètres qui servent pour les
algorithmes de calcul.
Et voici quelques idées en cas de problèmes.
Vous la choisissez dans la fenêtre de chargement.
L'image qui sera chargée sera aussitôt affichée et ses paramètres seront mis dans les
tableaux des paramètres.
S'affiche une page blanche où va apparaître peu à peu une image au fur et
à mesure de son calcul d'après ses paramètres.
En appuyant sur une touche, cela s'arrête (sauf pendant le contournage) et
vous pouvez la sauver pour la terminer plus tard.
Les lignes calculées sont choisies au hasard ce qui permet d'avoir assez vite
une bonne idée de l'image.
On finit le calcul et le dessin de l'image à l'écran. Cela sert également à charger l'image de l'écran vers la mémoire pour sauver ce qui se trouve à l'écran.
 |
|
Vous pouvez afficher des droites permettant de vous repérer sur le dessin, par
exemple, pour voir où est le point (0,0), vous choisissez dans le menu qui va s'afficher 0 pour X et 0 pour Y, en cliquant sur Afficher
vous voyez apparaître 2 droites, leur point de croisement est (0,0).
La droite x = la valeur choisie sera affichée (couleur 12) si votre nombre X est
supérieur à Gauche et est inférieur à Gauche+Largeur.
La droite y = la valeur choisie sera affichée (couleur 12) si votre nombre Y est
supérieur à Bas et est inférieur à Bas+Hauteur.
 |
Si Grille est à oui, alors des droites s'afficheront (couleur 5) ayant le Pas de la
grille en écart aussi bien vertical qu'horizontal. |
Par défaut, les droites ne sont pas sauvegardés avec l'image. Si vous les voulez, après les avoir affichées, vous faite Terminer puis vous sauvez l'image.
 |
Ils servent si votre algorithme est dans un fichier de formules. Vous pouvez donner un nom pour chaque variable utilisée (10 en tout) et commenter votre image grâce aux trois avant-dernières lignes. Chaque nom a une longueur de 19 caractères maximum et chaque commentaire de 29 caractères. La dernière ligne sert à valider. |
 |
Vous pouvez écrire un texte sur votre dessin, chaque lettre est constituée de
rectangles et d'arcs de cercle (elles sont décrites dans le fichier
LETTRES.DES). Chaque composant est vu comme un volume (cylindre ou portion de
sphère) reflétant l'image et c'est ce reflet qui donnera la lettre.
On ne peut écrire qu'une ligne sur une image ; pour en avoir plusieurs, il
faudra plusieurs morceaux d'image qui, se superposant, composeront le texte
voulu.
Ex : voir le scénario LETTRE.SNR.
Mis à oui, il permettra d'écrire sur l'image.
Ce paramètre multiplie l'épaisseur des traits et des arcs de cercle formant les lettres. On considère sa valeur absolue.
C'est le pourcentage de la largeur de l'écran que prendra
votre texte. Du nombre de lettres et de la largeur choisie dépendra
la hauteur, étant donné qu'une lettre s'inscrit dans un carré.
Ex : la largeur est de 100, il y a quatre lettres, donc la hauteur de
la phrase est le quart de celle de l'image (si les dimensions de l'image respecte bien le rapport 3/4).
Ce paramètre sert à positionner le milieu du texte en hauteur.
Ex : s'il est à 50 votre phrase sera au milieu de l'écran pour la
hauteur. 0 correspond au bas de l'écran et l'on verra la moitié haute.
Ce paramètre sert à positionner votre texte dans la largeur.
Valeurs : 0 pour centrer, 1 pour positionner à gauche, 2 pour
positionner à droite.
S'il est mis à oui, alors ne sera calculée et sauvée que le
rectangle de l'image encadrant votre texte. Cela permet un gain de
temps intéressant et surtout la possibilité de recouvrir en partie
une autre image.
Ex : Pour composer l'image avec le texte suivant :
BONJOUR
A TOUS
il faut, après avoir calculé les deux images nécessaires, charger
l'image BONJ1 (qui est entière), la recouvrir avec l'image
BONJ2 (qui est un morceau), mettre ce paramètre à non,
faire Terminer et finalement sauver. Et l'on obtient BONJOUR.
Plus il est grand, plus les volumes composant les lettres considérées sont loin de l'image et en reflète une plus grande partie. S'il est à 0, alors les volumes sont tangents à l'image.
Il multiplie la taille des lettres et leur épaisseur sans les écarter les unes des autres. En négatif, il inverse les lettres (le haut devient le bas et la droite devient la gauche).
Il se compose de un ou plusieurs mots qui seront écrit sur
une même ligne. Le maximum est de 29 caractères.
Les lettres sont
décrites dans LETTRES.DES, seules les majuscules sont fournies plus
- et a.
Vous pouvez compléter ce fichier (voir lettre.doc).
Confirme la saisie des paramètres.
Les paramètres d'une image sont les éléments nécessaires à l'ordinateur pour le
calcul de l'image.
Tous les paramètres qui sont des nombres à virgule plus le paramètre de
profondeur de calcul font changer continûment l'image, c'est à dire que si vous
faite varier un peu le paramètre alors l'image changera un peu.
On considère que l'écran est une portion du plan complexe, chaque point sera
vu avec une coordonnée en x (l'axe horizontal) et une en y (l'axe vertical).
Quand vous choisissez un nouveau rectangle avec Gauche, Bas, Largeur,
Hauteur et Angle, vous délimitez un rectangle, de plus vous pouvez le déformer
(allongé en hauteur ou en largeur) en n'ayant pas Hauteur/Largeur=3/4.
Vous pouvez aussi le choisir avec la Souris.
Grâce à ce fichier, vous allez pouvoir écrire vos formules et voir
les dessins résultants. Par défaut (pas de nom), vous avez 20 formules (codées
de 0 à 19) dans le logiciel.
Comment l'écrire : Dans un éditeur de texte, vous écrivez votre formule avec un
numéro d'algorithme, vous la sauvez au format ASCII avec l'extension frl.
Ensuite vous faites appel à un utilitaire FORMULE.EXE qui rend votre formule
assimilable par AIMFRACT.
Dans AIMFRACT, vous écrivez votre nom de fichier à Fichier de Formule, le bon
numéro à Algorithme, éventuellement vous changez d'autres paramètres et alors
le logiciel dessine votre image.
La méthode d'écriture, ainsi que les conseils, sont expliqués dans
FORMULE.DOC.
Dans votre Fichier de Formules, vous pouvez écrire plusieurs formules, chacune
devant avoir un numéro d'algorithme différent.
Vous pouvez avoir plusieurs Fichiers de Formules.
 |
Les Paramètres Annexes vous fournissent de nouvelles variables. |
FORMULE.EXE écrit à partir de votre fichier votre.frl un nouveau fichier votre.cop ou votre.emu, il essaye d'optimiser les calculs à faire et écrit les fonctions en langage machine afin d'optimiser les temps de calcul lors du dessin. Selon que vous avez Coprocesseur à oui ou non, sera considéré le fichier votre.cop ou votre.emu.
Il y a 20 algorithmes numérotés de 0 à 19, l'algorithme sert à déterminer quel
type de calcul est effectué par l'ordinateur.
Ce qui suit n'est pas nécessaire à l'utilisation du programme.
Tous les algorithmes sont faits à partir d'une fonction que l'on calcule de
façon itérative, c'est à dire f(0), f(f(0)), f(f(f(0))) ...
On arrête le calcul dès que la norme de f(z) est supérieure à la Norme choisie
ou que l'on a itéré le calcul n fois (n étant la Profondeur choisie).
Le nombre de fois (k) que le calcul a été effectué sert à déterminer la couleur.
La couleur 16 représente
la convergence et les autres couleurs représentent à quelle étape le calcul s'est arrêté.
Par exemple, s'il a divergé au 31ième coup et que la Profondeur est de 150, il
aura la 4ième couleur.
Le paramètre Tornade change la répartition des couleurs.
Convergence : Lors du calcul d'un point, on recommence le calcul si la norme du
résultat est inférieure à la Norme choisie, et ceci jusqu'à ce que le nombre
de calculs faits soit égal à la Profondeur.
On dit qu'un point converge pour AIMFRACT si le nombre de calculs faits est
égal à la profondeur. Sa couleur est la 16ième.
Les fonctions utilisées sont, entre autres,
norme(z) = racine(x²+y²) où z est un nombre complexe : z=x+iy
pow(z1,z2) indique z1 à la puissance z2, z1 et z2 pouvant être des complexes.
Si vous connaissez le langage C, voici le code de l'algo 0 :
norm2 = norme*norme; if (puisr == 2) { for ( x = consx+(coord?x0:0), y = consy+(coord?y0:0), k = 0; k < profondeur && ((sx=x*x)+(sy=y*y)) < norm2; k++) { y = 2*x*y+y0; x = sx-sy+x0; } } else { double r,teta; for ( x = consx+(coord?x0:0), y = consy+(coord?y0:0), k = 0; k < profondeur && (r=hypot(x,y)) < norme; k++) { if (r != 0) { teta = acos(x/r)*puisr; if (y < 0) teta = -teta; r = pow(r,puisr); x = r*cos(teta); y = r*sin(teta); } y = y0+y; x = x0+x; } }
Algorithme 0 : Ensemble de MandelbrotC'est l'ensemble fractal le plus classique.
Pour cet ensemble la fonction que l'on itère est f(z)=z²+p où p est le point du
plan auquel on s'intéresse (z et p sont des complexes).
On calcule ainsi
![[home]](/homepage/images/home.gif)
Home![[no previous]](/homepage/images/toc-grey.gif)
![[no previous]](/homepage/images/prev-grey.gif)
![[no previous]](/homepage/images/next-grey.gif)
f(p) = 0
f(f(p)) = f(p)²+p et ainsi de suite tant que norme(f(p)) < Norme
Ici le calcul a été agrémenté de paramètres supplémentaires de manière à pouvoir
obtenir des images dérivées de l'ensemble de Mandelbrot.
Ainsi tous les paramètres sauf Puissance imaginaire auront de l'effet.
Dans le cas d'un ordinateur avec coprocesseur cet algorithme a été
particulièrement optimisé.
Si l'on veut utiliser le même algorithme que le 0 mais où Puissance imaginaire
est utilisé il faut utiliser le 18. Le 18 est bien plus lent (avec ou sans
coprocesseur).
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + (z.x)²-(z.y)² - 2*i*z.x*z.y U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + z² + 2*z.x*z.y + p.y U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = z² + p.x*(2*z.x*z.y+p.y*z.x) + z.x+p.y U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + pow(z,PuisR+norme(p)) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p +PuisI*(ConstX-p.x) + i*PuisI*(ConstY-p.y) ConstX = ConstX + PuisI*(p.x-ConstX), ConstY = ConstY + PuisI*(p.y-ConstY), f(z) = pow(z,PuisR) + ConstX + i*ConstY U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
Le paramètre Puissance Imaginaire ne sert pas ici en tant que puissance mais
est utilisé pour passer de l'ensemble de Julia à celui de Mandelbrot.
Si ce paramètre est égal à 0, on a l'ensemble de Julia, s'il est égal à 0.5, on
trouve celui de Mandelbrot.
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + pow(z,norme(z)+2) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + r*(ConstX*cos(theta*PuisR) + i*ConstY*sin(theta*PuisR)) où r = norme(z) et theta = l'angle de z modulo PI U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + pow(r,ConstX)*cos(theta*PuisR) + i*pow(r,ConstY)*sin(theta*PuisR) où r = norme(z) et theta = angle de z modulo PI U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + i*2*z.x*z.y + (z.x)² - (2*z.x*z.y+p.y)² U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + (z.x)²-(z.y)² + i*2*z.y*((z.x)²-(z.y)²+p.x) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + z.x*z.y + (z.y)² + i*((z.x)²-z.x*z.y) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + z.x*z.y + z.x + i*(z.x*z.y+z.y) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + z.y - z.x + i*(z.x*z.y-z.y) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + ((z.x+z.y)²+1)/((z.x)²+1) + i*((z.x+z.y)²+1)/((z.y)²+1) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + (z.x+z.y)²/(³z.x-z.y³+1) + i*(z.x+z.y)²/(³z.x*z.y³+1) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = z.y-z.x + i*(z.x*z.y-z.y) U(n+1) = f(U(n)) + p/(n+1) Arrêt quand norme(U(n)) >= Norme
Algorithme 17 : Ensemble de JuliaU(0) = p f(z) = pow(z,PuisR) + ConstX + i*ConstY U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
Pour obtenir une belle image, il est intéressant de prendre comme constante un des points qui se trouvent sur le bord de l'ensemble de Mandelbrot.
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + pow(z,PuisR + i*PuisI) U(n+1) = f(U(n)) Arrêt quand norme(U(n)) >= Norme
U(0) = p*Coord + ConstX + i*ConstY f(z) = p + exp(g(z) * (PuisR + i*PuisI)) avec si real(z) !=0, g(z) = log(norm(z))/2 + i*atan(imag(z)/real(z)) sinon , g(z) = log(abso(imag(z))) + i*(imag(z)<0 ? -PI/2 :PI/2) U(n+1) = f(U(n)) Arrêt quand racine(norme(U(n))) >= Norme
Algorithmes qui l'utilisent : tous
Valeurs possibles : entiers de 1 à 65500 (pas de négatif)
Exemple de valeur : 50
C'est ce qui permet d'avoir un dessin plus (vers 65500) ou moins (vers 1)
précis.
Plus la profondeur est grande plus l'ordinateur s'applique (plus il calcule)
mais s'appliquer ne sert à rien sur des images assez simples, il se peut que les
profondeurs 100 et 300 donnent pratiquement le même dessin.
Algorithmes qui l'utilisent : 0,4,5,7,8,17,18,19
Valeurs possibles : tout réel
Exemple de valeur : 2
Certains algorithmes utilisent des puissances complexes (a + ib), a est la
partie réelle, c'est celle utilisée pour les algorithmes n'utilisant que les
puissances réelles.
Algorithmes qui l'utilisent : 5,18,19
Valeurs possibles : tout réel
Exemple de valeur : 0
Algorithmes qui l'utilisent : tous sauf les algorithmes 5 et 17
Exemple de valeur : non
Mettre Coordonnées à oui revient à ajouter p à f(p) au premier coup (c'est
à dire f(p) = p et non f(p) = 0), ce paramètre n'a aucun effet les coups
suivants.
Algorithmes qui l'utilisent : tous
Exemple de valeur : non
Au lieu de prendre p comme point de départ, on prend 1/p.
C'est plus lent car la procédure de contournage ne peut
plus être utilisée ou rarement.
Comme exemple comparer les images : et 
Algorithmes qui l'utilisent : tous
Exemple de valeur : oui
Que fait contourne : Quand contourne est à oui, lors du calcul de l'image, si
le programme tombe sur un point de convergence, il va faire le tour de
l'ensemble des points convergents qui touchent le point qu'il a trouvé.
Une fois le tour fait, il remplit l'intérieur de la couleur de convergence (16).
Inconvénient de contourne : Si dans l'image que l'on calcule, il y a une plage
de non convergence qui est incluse dans une plage de convergence alors la plage
de non convergence n'apparaîtra pas et sera remplacée par la plage de
convergence.
Ceci ne se produit pas pour l'ensemble de Mandelbrot, pour les autres dessins,
si l'on n'est pas sûr, on peut commencer par faire un petit test en commençant
le calcul sans le contournage (en particulier si Inversion est à oui ou si
la Puissance Réelle est négative).
Avantage de contourne : Pour les plages de convergence, on ne calcule que les
bords, or les points convergents sont les plus longs à calculer. Avec
contourne, quand on augmente la profondeur de calcul le temps de calcul total
augmente faiblement.
Ceci est à tempérer par le fait que le bord de l'ensemble de Mandelbrot est de
dimension 2 ! (et certainement pour pas mal d'autres images), il en résulte que
plus on va voir des détails petits et tarabiscotés de l'image, plus le bord de
l'ensemble de convergence se comporte comme une surface et est donc long à
calculer.
Algorithmes qui l'utilisent : tous
Exemple de valeur : non
Avec cette option à oui, les couleurs sont réparties ainsi :
Les points qui convergent auront toujours la 16ième couleur,
les points qui divergent au (Profondeur-1)nième coup auront la 15ième couleur,
ceux qui divergent au (Profondeur-2)nième coup auront la 14ième couleur,...
ceux qui divergent au (Profondeur-15)nième coup auront la première couleur,
ceux qui divergent au (Profondeur-16)nième coup auront la 15ième couleur, etc
Cela donne un effet de profondeur et peut aider à repérer les plages de
points divergeant en même temps, l'idéal serait d'avoir autant de couleurs
que d'étapes de calcul possibles.
Algorithmes qui l'utilisent : tous
Valeurs possibles : tout réel
Exemple de valeur : 0
X veut dire que l'on ajoute cette constante à la partie réelle.
Algorithmes qui l'utilisent : tous
Valeurs possibles : tout réel
Exemple de valeur : 0
Y veut dire que l'on ajoute cette constante à la partie imaginaire.
Algorithmes qui l'utilisent : tous
Valeurs possibles : tout réel positif
Exemple de valeur : 2
C'est le point d'arrêt du calcul : quand la norme du point calculé à un moment
de l'itération devient plus grande que celle que vous avez choisie ici, le
calcul est fini et la couleur est décidée.
Si, à tout moment de l'itération, la norme du point calculée est inférieure à
celle donnée ici, le calcul s'arrête quand la Profondeur est atteinte et la
couleur de ce point est celle de la convergence.
Dans les versions précédentes (< 3), la norme était dépendante de l'algorithme
ex : algo 10, norme = 3.
Cela permet de choisir un détail de l'image. Avec la souris on choisit deux
points du rectangle voulu.
Un menu s'affiche : 
Il détermine à quel point le côté gauche du cadre est proche ou non de l'axe
vertical.
Ex : Mandel est à moins 2 du point (0,0) avec une largeur
d'environ 2.5, si vous choisissez Gauche à -100, une largeur de 200, Bas à -50 et
une hauteur de 100, vous aurez un tout petit Mandel déformé.
Il détermine à quel point le bas du cadre est proche ou non de l'axe horizontal.
C'est la largeur totale en réel de votre image.
C'est la hauteur totale en réel de votre image.
C'est l'angle en degré de l'image par rapport à l'horizontale.
Quand on a modifié les paramètres et que l'on veut garder les modifications, on choisit Valider, sinon on fait Esc.
Les problèmes recensés ici sont ceux pour lesquels il n'y a pas de messages d'erreur, pas de plantage, juste une image toute petite ou toute noire, pas de texte qui s'affiche ...
Vous n'arrivez pas à sauver une image avec la grille affichée ou plusieurs lignes de texte ?
Vos lettres sont obliques, déformées en largeur ou en hauteur ... : la cause en est que l'image, sur laquelle elles sont écrites, est déformée (il n'y a pas la proportion de 3/4 entre la Hauteur et la Largeur).
http://www.maretmanu.org/homepage/aimfract/image.html
Date de création : 7 juin 1997
Dernière modification : 14 December 2000