DEL remove useless code
[powerfractal.git] / Src / Power_calculator.adb
1 ------------------------------------------------------------------------------------------------
2 -- Nom : Power_Calculator / fait partie du programme Power Fractal --
3 -- --
4 -- Auteurs : Gregory Burri & Adrien Crivelli --
5 ------------------------------------------------------------------------------------------------
6 -- But : Outils de calculs des fractals ainsi que de l'antialiasing --
7 ------------------------------------------------------------------------------------------------
8
9 with Ada.Numerics; use Ada.Numerics;
10 with Ada.Numerics.Generic_Elementary_Functions; --Fonctions mathematiques avancees
11 with Ada.Numerics.Generic_Complex_Types;
12 with Ada.Text_IO;
13
14 package body Power_Calculator is
15
16 ------------------------------------------------------------------------------------------------
17 -- Nom : Calcul_Antialiasing --
18 -- But : Contracter une matrice en une autre 4 fois plus petite --
19 -- --
20 -- Parametres ----------------------------------------------------------------------------------
21 -- In : La matrice a antialiasinger --
22 -- --
23 -- return : La matrice traitee --
24 ------------------------------------------------------------------------------------------------
25 function Calcul_Antialiasing(Matrice_Antialiasing : T_Matrice_Tampon) return T_Matrice_Tampon is
26
27 X, Y : Natural; --Variables pour le parcours de la matrice
28
29 --La matrice de retour, qui est evidement 2 fois plus petite que celle en entrer
30 Matrice_Retour : T_Matrice_Tampon ( 0..(Matrice_Antialiasing'Last(1) - 1) / 2,
31 0..(Matrice_Antialiasing'Last(2) - 1) / 2 );
32 begin --Calcul_Antialiasing
33
34 X := 0;
35 --Parcours toutes les colonnes impaires
36 while X <= Matrice_Antialiasing'Last(1) - 1 loop
37 Y:=0;
38 --Parcours toutes les lignes impaires
39 while Y <= Matrice_Antialiasing'Last(2) - 1 loop
40
41 --Fait la moyenne de quatre points pour n'en former qu'un seul
42 Matrice_Retour(X/2, Y/2).R := Byte ((Integer(Matrice_Antialiasing(X, Y).R)
43 + Integer(Matrice_Antialiasing(X + 1,Y).R)
44 + Integer(Matrice_Antialiasing(X, Y + 1).R)
45 + Integer(Matrice_Antialiasing(X + 1, Y + 1).R))
46 / 4);
47
48 Matrice_Retour(X/2, Y/2).G := Byte ((Integer(Matrice_Antialiasing(X, Y).G)
49 + Integer(Matrice_Antialiasing(X + 1,Y).G)
50 + Integer(Matrice_Antialiasing(X,Y + 1).G)
51 + Integer(Matrice_Antialiasing(X + 1, Y + 1).G))
52 / 4);
53
54 Matrice_Retour(X/2, Y/2).B := Byte ((Integer(Matrice_Antialiasing(X, Y).B)
55 + Integer(Matrice_Antialiasing(X + 1,Y).B)
56 + Integer(Matrice_Antialiasing(X, Y + 1).B)
57 + Integer(Matrice_Antialiasing(X + 1, Y + 1).B))
58 / 4);
59 Y:=Y+2;
60 end loop;
61
62 X:=X+2;
63 end loop;
64
65 return Matrice_Retour; --retourne la matrice quatre fois plus petite
66 end;
67
68
69 ------------------------------------------------------------------------------------------------
70 -- Nom : Change_Angle --
71 -- But : Changer l'angle d'un nombre complexe par rapport au centre de l'ecran --
72 -- --
73 -- Parametres ----------------------------------------------------------------------------------
74 -- In : * La fractal, --
75 -- --
76 -- In out : * Partie reel du nb complexe : A --
77 -- * Partie imaginaire du nb complexe : B --
78 ------------------------------------------------------------------------------------------------
79 procedure Change_Angle (A, B : in out Long_Float; Fractal : Cara_Fractal) is
80
81 Rayon : Long_Float; --Le rayon du nombre complexe
82 Phi : Long_Float; --Le nouvel angle calcule
83
84 --L'angle en parametre est converti en radian
85 Angle_Rad : Long_Float := Pi * Fractal.Angle / 180.0;
86
87 --Pour pouvoir faire des operations (sin cos etc..) sur des Long_Float
88 package Elementary_Functions_Long_Float
89 is new Ada.Numerics.Generic_Elementary_Functions (Long_Float);
90 use Elementary_Functions_Long_Float;
91
92 begin
93
94 --Ramene l'origine du nombre complexe au centre de l'ecran
95 A := A - Fractal.Centre.X;
96 B := B - Fractal.Centre.Y;
97 --
98 --Pour eviter la division par zero
99 if A /= 0.0 then
100
101 --Si 'A' est negatif => (l'angle est compris entre : 90 < angle < -90)
102 if A < 0.0 then
103 --Calcul de l'angle en additionnant a l'angle de base l'angle que l'on veut
104 Phi := Arctan( B / A ) + Angle_Rad + Pi;
105 else
106 Phi := Arctan( B / A ) + Angle_Rad;
107 --
108 end if;
109
110 else
111
112 --si l'angle est compris entre : 180 < angle < 360 alors
113 if B < 0.0 then
114 --Calcul de l'angle en additionnant a Pi/2.0 l'angle que l'on veut
115 Phi := Pi / 2.0 + Angle_Rad + Pi;
116 else
117 Phi := Pi / 2.0 + Angle_Rad;
118 --
119 end if;
120
121 end if;
122
123 Rayon := Sqrt( A**2 + B**2 ); --Calcul le rayon (module)
124 A := Rayon * Cos( Phi ); --Calcul la partie reel
125 B := Rayon * Sin( Phi ); --Calcul la partie imaginaire
126
127 --Ramene l'origine du nombre comples au centre (0,0)
128 A := A + Fractal.Centre.X;
129 B := B + Fractal.Centre.Y;
130 --
131
132 end Change_Angle;
133
134
135 ------------------------------------------------------------------------------------------------
136 -- Nom : Mandel_Gen --
137 -- But : Genere une matrice d'iteration selon l' ensemble de Mandelbrot --
138 -- Z(n+1) = Z(n)^2 + Z(o) --
139 -- Parametres ----------------------------------------------------------------------------------
140 -- In : * Largeur_Zone et Hauteur_Zone : Dimension de la zone de calcul --
141 -- * Fractal : L'ensemble des caracteristiques de la fractal --
142 -- --
143 -- return : * Une matrice contenant la fractal sous forme de nombre d'iteration pour chaque --
144 -- point --
145 ------------------------------------------------------------------------------------------------
146 function Mandel_Gen (Largeur_Zone, Hauteur_Zone : Natural; Fractal : Cara_Fractal)
147 return T_Matrice_Iteration is
148
149 ------Nombre complexe : Z = A + Bj------
150
151 package Complex_Long_Float is new Ada.Numerics.Generic_Complex_Types(Long_Float);
152 use Complex_Long_Float;
153 use Ada.Text_IO;
154
155 Zo : Complex;
156 Pas : Complex;
157 Za : Complex;
158 Zs : Complex;
159
160 N : constant Natural := 20; --Precision de l'interpolation
161 Ao,Bo-- la valeur reel et imaginaire du point en cours de traitement : Z(o)
162 : Long_Float;
163
164 Nb_Iteration : Float; --Pour compter le nombre d'iteration
165
166 --La matrice est cree et retournee
167 Matrice_Retour : T_Matrice_Iteration (0..Largeur_Zone, 0..Hauteur_Zone);
168
169 --la hauteur et la largeur en long float
170 Largeur_Zone_Tmp_Float : Long_Float := Long_Float(Largeur_Zone);
171 Hauteur_Zone_Tmp_Float : Long_Float := Long_Float(Hauteur_Zone);
172
173 --Variable precalculee pour ne pas avoir a la calculer a chaque iteration
174 Pre_Calcul : Long_Float;
175
176 begin -- Mandel_Gen
177
178 Pre_Calcul := (2.0 * Largeur_Zone_Tmp_Float) * Fractal.Zoom;
179
180 --Parcours toute la dimension X de l'affichage (pixel)
181 for X in 0..Largeur_Zone loop
182
183 --Parcours toute la dimension Y de l'affichage (pixel)
184 for Y in 0..Hauteur_Zone loop
185
186 --Convertie la valeur x du point a l'ecran(pixel) en valeur reel sur la fractal
187 --Voir la doc pour plus d'informations
188 Ao := ((Long_Float(X) / Largeur_Zone_Tmp_Float) - 0.5 ) /
189 Fractal.Zoom + Fractal.Centre.X ;
190
191 --Convertie la valeur y du point a l'ecran(pixel) en valeur reel sur la fractal
192 --Voir la doc pour plus d'informations
193 Bo := (-2.0 * Long_Float(Y) + Hauteur_Zone_Tmp_Float) / Pre_Calcul + Fractal.Centre.Y;
194
195 Change_Angle(Ao, Bo, Fractal);
196
197 Zo := Compose_From_Cartesian(Ao , Bo);
198 Za := Zo;
199
200 Nb_Iteration := 0.0; --Initialise le compteur d'iteration a 0
201
202
203 --Boucle calculant la divergence d'un point du plan
204 M : loop
205
206 Zs := Za**2 + Zo;
207 Pas := Zs/Long_Float(N) - Za/Long_Float(N);
208
209 for I in 1..N loop
210
211 --Sort si le nombre maximale d'iteration a ete atteind
212 --ou si le module du nb complexe a dapasse la limite de divergence.
213 --Astuce : la limite represente en fait le carre du module,
214 --ce qui permet de faire moins de calculs
215 exit M when (Re(Za)**2 + Im(Za)**2) > Fractal.C_Diverge_Limite ;
216 Nb_Iteration := Nb_Iteration + 1.0/Float(N);
217 Za := Za + Pas;
218
219 end loop;
220
221 --Za := Zs; --a enlever
222 exit when Nb_Iteration >= Float(Fractal.Nb_Iteration_Max);
223
224 end loop M;
225
226 --Enregistre le point calcule dans la matrice d'iteration (Global)
227 Matrice_Retour(X,Y) := Nb_Iteration;
228 --Put(Float'Image(Nb_Iteration));
229
230 end loop;
231 end loop;
232
233 for I in Matrice_Retour'range(1) loop
234
235 Put_Line(Float'Image(Matrice_Retour(I,0)));
236
237 end loop;
238
239
240 return Matrice_Retour; --Retourne la matrice
241
242 end Mandel_Gen;
243
244 ------------------------------------------------------------------------------------------------
245 -- Nom : Julia_Gen --
246 -- But : Genere une matrice d'iteration selon l' ensemble de Julia --
247 -- Z(n+1) = Z(n)^2 + c 'c' etant une constante arbitraire --
248 -- Parametres ----------------------------------------------------------------------------------
249 -- In : * Largeur_zone et Hauteur_Zone : Dimension de la zone de calcul --
250 -- * Fractal : L'ensemble des caracteristiques de la fractal --
251 -- --
252 -- return : * Une matrice contenant la fractal sous forme de nombre d'iteration pour chaque --
253 -- point --
254 ------------------------------------------------------------------------------------------------
255 function Julia_Gen (Largeur_Zone, Hauteur_Zone : Natural; Fractal : Cara_Fractal)
256 return T_Matrice_Iteration is
257
258
259 ------Nombre complexe : Z = A + Bj------
260
261 package Complex_Long_Float is new Ada.Numerics.Generic_Complex_Types(Long_Float);
262 use Complex_Long_Float;
263 use Ada.Text_IO;
264
265 Pas : Complex;
266 Za : Complex;
267 Zs : Complex;
268 C : Complex := Compose_From_Cartesian (Fractal.Cx, Fractal.Cy);
269
270 N : constant Natural := 20; --Precision de l'interpolation
271 Ao,Bo-- la valeur reel et imaginaire du point en cours de traitement : Z(o)
272 : Long_Float;
273
274 Nb_Iteration : Float; --Pour compter le nombre d'iteration
275
276 --La matrice est cree et retournee
277 Matrice_Retour : T_Matrice_Iteration (0..Largeur_Zone, 0..Hauteur_Zone);
278
279 --la hauteur et la largeur en long float
280 Largeur_Zone_Tmp_Float : Long_Float := Long_Float(Largeur_Zone);
281 Hauteur_Zone_Tmp_Float : Long_Float := Long_Float(Hauteur_Zone);
282
283 --Variable precalculee pour ne pas avoir a la calculer a chaque iteration
284 Pre_Calcul : Long_Float;
285
286 begin -- Mandel_Gen
287
288 Pre_Calcul := (2.0 * Largeur_Zone_Tmp_Float) * Fractal.Zoom;
289
290 --Parcours toute la dimension X de l'affichage (pixel)
291 for X in 0..Largeur_Zone loop
292
293 --Parcours toute la dimension Y de l'affichage (pixel)
294 for Y in 0..Hauteur_Zone loop
295
296 --Convertie la valeur x du point a l'ecran(pixel) en valeur reel sur la fractal
297 --Voir la doc pour plus d'informations
298 Ao := ((Long_Float(X) / Largeur_Zone_Tmp_Float) - 0.5 ) /
299 Fractal.Zoom + Fractal.Centre.X ;
300
301 --Convertie la valeur y du point a l'ecran(pixel) en valeur reel sur la fractal
302 --Voir la doc pour plus d'informations
303 Bo := (-2.0 * Long_Float(Y) + Hauteur_Zone_Tmp_Float) / Pre_Calcul + Fractal.Centre.Y;
304
305 Change_Angle(Ao, Bo, Fractal);
306
307 Za := Compose_From_Cartesian(Ao , Bo);
308
309 Nb_Iteration := 0.0; --Initialise le compteur d'iteration a 0
310
311
312 --Boucle calculant la divergence d'un point du plan
313 M : loop
314
315 Zs := Za**2 + C;
316 Pas := Zs/Long_Float(N) - Za/Long_Float(N);
317
318 for I in 1..N loop
319
320
321
322 --Sort si le nombre maximale d'iteration a ete atteind
323 --ou si le module du nb complexe a dapasse la limite de divergence.
324 --Astuce : la limite represente en fait le carre du module,
325 --ce qui permet de faire moins de calculs
326 exit M when (Re(Za)**2 + Im(Za)**2) > Fractal.C_Diverge_Limite ;
327 Nb_Iteration := Nb_Iteration + 1.0/Float(N);
328 Za := Za + Pas;
329
330 end loop;
331
332 Za := Zs; --a enlever
333 exit when Nb_Iteration >= Float(Fractal.Nb_Iteration_Max);
334
335 end loop M;
336
337 --Enregistre le point calcule dans la matrice d'iteration (Global)
338 Matrice_Retour(X,Y) := Nb_Iteration;
339 --Put(Float'Image(Nb_Iteration));
340
341 end loop;
342 end loop;
343 --Put(Float'Image(Matrice_Retour(0,0)));
344 return Matrice_Retour; --Retourne la matrice
345 end Julia_Gen;
346 end Power_Calculator;