Informatica 5 Liceo Scientifico Scienze Applicate/Frattali

Frattali

Un frattale è un oggetto geometrico, spesso un'immagine, definito da una funzione che ne permette la visualizzazione a fattori di ingrandimento arbitrari, questa immagine presenta la caratteristica di omototia interna, cioè se confronto una parte dell'immagine del frattale a una certa scala e l'immagine di un ingrandimento di una sezione di questa immagine si vede che sono molto simili nella loro geometria.

Ad esempio pensiamo che alla scala 1 l'immagine appaia come un quadrato, se ingrandiamo un punto del quadrato scopriamo che alla scala 13 è costituito da quadrati (magari di colore diverso ma con la stessa geometria) più piccoli che a loro volta se ingranditi ripresentano lo stesso aspetto geometrico.

Per capirci osserviamo il frattale di Sierpinski che rappresenta un triangolo in 2d

le immagini dei frattali sono particolarmente belle, in parte per i procedimenti matematici che le generano e in parte per la possibilità di zoomarle all'infinito e altre volte per le colorazioni che possono assumere.Un infinito viaggio in un universo geometrico che riscopre nuovi universi omotetici in ogni punto.

Nel passato si è pensato all'uso dei frattali per poter definire immagini naturali (foglie, alberi, montagne etc) ma oggi dei frattali rimane il fascino artistico delle immagini create.

Un frattale famoso è quello di MandelBrot la sua forma è

Mandelbrot p1130876

se si ingrandiscono alcune sezioni (alcune parti sono decisamente più belle di altre) si ottiene

e così via

La colorazione delle immagini esprime delle caratteristiche della funzione matematica che genera il frattale nei punti analizzati è al fattore di scala scelto.

Vediamo come generare le immagini

si decide di indagare una specifica area definita tramite una griglia di punti, a una determinata scala n, per ogni punto della griglia si indagano i termini della serie definita da

$z_{k+1}=z_{k}^{2}+zpunto$ per i valori di k da 0 a n $z_{k+1}$ e zpunto sono dei numeri complessi del tipo z=a+ib. $zpunto$ rappresenta le coordinate a b di un generico punto P della griglia. il valore di partenza $z_{0}$ è uguale a zero e quindi dalla formula si ottiene che $z_{1}=zpunto$ con lo scopo di cercare di individuare da quale valore di k sia possibile capire se la serie divergerà per

$k\rightarrow \infty$ il valore di k da cui possiamo stabilire la divergenza viene usato come indice di un vettore che contiene dei colori, il colore individuato è quello che nell'immagine viene utilizzato per rappresentare il punto zpunto della griglia di cui si è analizzata la serie, se analizzando la serie fino al termine n non si riesce a capire se la serie divergerà viene associato il colore nero (RGB 0 0 0). un criterio usato per stabilire l'eventuale divergenza partendo dal valore del termine $z_{k}$ è $absz_{k}>=2$

ora scriviamo il programma

numeroiterazioni = 400;
puntigriglia = 1000;
xlim = [-0.7800, -0.7700];
ylim = [ -0.1400,  -0.1200];

x = linspace( xlim(1), xlim(2), puntigriglia );
y = linspace( ylim(1), ylim(2), puntigriglia );
[xGriglia,yGriglia] = meshgrid( x, y );
z0 = xGriglia + 1i*yGriglia;
conta = ones( size(z0) );

z = z0;
for n = 0:numeroiterazioni
   z = z.*z + z0;
   ancorauno = abs( z )<=2;
   conta = conta + ancorauno;
   n
end


imagesc( conta );
colormap( [jet();0 0 0] );
axis off

Alcuni punti del set di Mandelbrot sono più belli di altri, ad esempio:

The Valley of the Seahorses  attorno a -.7700-.1300i
West Wing -1.6735-0.0003318i
Buzzsaw   0.001643721971153+0.822467633298876i
Nebula    0.73752777-0.12849548

Per vedere il merletto di Koch si procede in questo modo: dato un segmento con estremi i punti P1 e P2, lo si divide in tre parti uguali individuanto P3 e P4, i punti lungo il segmento sono nell'ordine P1 P3 P4 P2, ora si costruisce un triangolo equilatero con base P3-P4 e il nuovo vertice (oltre a P3 e P4 ) lo chiamiamo P, la base P3-P4 viene eliminata. La spezzata diventa allora P1 P3 P P4 P2. Ricorsivamento per ognuno dei tratti ottenuti si ripete il procedimanto, fermandosi a una certa profondità n della ricorsione e si disegnano i tratti ottenuti a quella profondità.

ecco il programma in octave

file fkoch.m

function disegna( x1,y1,x2,y2,iter )


%angle = -60*pi/180;

x3 = (2*x1+x2)/3;
y3 = (2*y1+y2)/3;

x4 = (x1+2*x2)/3;
y4 = (y1+2*y2)/3;

%x = x3 + (x4-x3)*cos(angle)+(y4-y3)*sin(angle);
%y = y3 - (x4-x3)*sin(angle)+(y4-y3)*cos(angle);
 
x=(x1+x2-0.57735*(y2-y1))/2;
y=(y1+y2+0.57735*(x2-x1))/2;

if(iter > 0)
 
 fkoch(x1, y1, x3, y3, iter-1);
 fkoch(x3, y3, x, y, iter-1);
 fkoch(x, y, x4, y4, iter-1);
 fkoch(x4, y4, x2, y2, iter-1);
 
else
 
 A=[ x1 x3];
 B=[ y1,y3];
 line(A,B);
 A=[ x3 x];
 B=[ y3,y];
 line(A,B);
 A=[ x x4];
 B=[ y,y4];
  line(A,B);
 A=[ x4 x2];
 B=[ y4, y2];
 line(A,B);
 
endif
endfunction

per richiamare il codice

fkoch(1,45,91,45,0);
fkoch(91,-45,1,-45,0)
fkoch(1,-45,1,45,0)
fkoch(91,45,91,-45,0)