Ciao. Ho la passione per i frattali da ragazzino. Ho tentanto di fare un sorgente che generasse l'insieme di julia "parente di mandelbrot".
Ho provato con le SDL e mi si è creata una enorme confusione in testa.
SARA' LO STRESS!!
Il problema è proprio rappresentare i punti sullo schermo all'interno di una finestra oppure memorizzarli in una superfice virtuale per poi stamparla a video. Usando le superfici virtuali si potrebbero creare infiniti frattali che differiscono per piccoli particolari da poter mostrare in sequenza per creare un animazione. Riporto l'algoritmo per generare l'insieme di JULIA.
Spero qualcuno di voi mi aiuti a realizzarlo.
L'insieme di mandelbrot come quello di julia si ottiene trasformando con delle funzioni le coordinate di tutti i punti di una porzione di piano. Otteniamo così un nuovo piano di forma differente "non rettangolare". Riapplicando la trasformazione al nuovo piano si ottiene un terzo piano. Iterando si ottiene l'intero frattale.
int main()
{
// Queste quattro variabili definiscono la zona dell'insieme
// di Julia
const float xmin, ymin, xmax, ymax;
xmin = -2;
xmax = 2;
ymin = -2;
ymax = 2;
// Queste due, invece, la risoluzione dello schermo
const int xscr, yscr;
xscr = 1280;
yscr = 1024;
// Queste ci servono per qualche conto: ogni pixel
// rappresenterà una finestra sull'insieme di dimensioni
// dx e dy
float dx = (xmax - xmin) / xscr;
float dy = (ymin - ymax) / yscr;
// Questo sarà il massimo numero di iterazioni,
// ossia il numero di iterazioni dopo il quale
// un punto sarà dichiarato, d'ufficio,
// sedentario
const int maxiter = 2000;
// Questa sarà la distanza dall'origine superata la quale
// un punto sarà dichiarato, invece, irrecuperabile
const float bailout = 4;
// E adesso, la parte reale e quella immaginaria del parametro c
float real_c = .11031;
float imag_c = -.67037;
// Inizia il ciclo principale, che prende ogni punto della finestra
// di visualizzazione sul piano complesso, applica la formulaccia e
// vede cosa succede
// sx e sy saranno le coordinate di schermo;
// rx e ry la parte reale ed immaginaria del punto corrispondente
// al pixel di coordinate sx e sy
// rx_squared e ry_squared i loro quadrati
// modulus il modulo del punto
float rx_squared, ry_squared;
float modulus;
int iter;
for(int sy = 0; y <= ymax; y++)
{
for(int sx = 0; x <= xmax; x++)
{
rx = xmin + sx * dx;
ry = ymax + sy * dy;
rx_squared = rx^2;
ry_squared = ry^2;
// Ecco il ciclo che itera la successione
iter = 0;
// Togliendo il commento a queste due righe, si genera un insieme
// di Mandelbrot, invece che uno di Julia... se ne parla più
// avanti
// float real_c = rx;
// float imag_c = ry;
do
{
// Queste due istruzioni elevano il numero complesso
// di parte reale rx e parte immaginaria ry al quadrato,
// ed aggiungono c
ry = 2 * rx * ry + imag_c;
rx = rx_squared - ry_squared + real_c;
rx_squared = rx^2;
ry_squared = ry^2;
modulus = sqrt(rx_squared + ry_squared);
} while ((++iter < maxiter) && (modulus < bailout));
// Che facciamo, vogliamo anche tracciare qualcosa sullo schermo?
// La funzione void plot(x, y, color) dovrebbe essere,
// preferibilmente, una funzione che
// tracci un pixel di colore color alle coordinate x, y
//color dovrebbe essere l'indice di un colore nella palette dello
//schermo attuale
// Se volete fare i figaccioni, abbandonare le vetuste palette e
// fare tutto in true color,
// il discorso si complica, ma non troppo. Comunque, io non scendo
// in dettagli
// Voi e le vostre directx...
// Nota: usare iter come colore ci dà la possibilità di colorare
// ogni pixel
// in base al numero di iterazioni che ha impiegato per dirigersi
// verso l'infinito
// Nel caso non si sia diretto verso l'infinito, il colore sarà
// maxiter
plot(sx, sy, iter);
}
}
}
"Questo Sorgente non lo ho scritto io"
Aiutatemi
:°°(
Ciao
Rispondi quotando
