Come programmare un frattale?

Question

Non ho alcuna esperienza con la programmazione di frattali. Ovviamente ho visto le famose immagini di Mandelbrot e simili.

Potete fornirmi semplici algoritmi per i frattali.

Il linguaggio di programmazione non ha importanza, ma conosco meglio ActionScript, C #, Java.

So che se google frattali ricevo molte informazioni (complicate) ma vorrei iniziare con un semplice algoritmo e giocarci.

Anche i suggerimenti per migliorare l'algoritmo di base sono i benvenuti, come come renderli in quei colori adorabili e simili.

Answer 1

La programmazione di Mandelbrot è semplice.
Il mio codice quick-n-dirty è sotto (non garantito per essere privo di bug, ma una buona struttura).

Ecco lo schema: Il set di Mandelbrot si trova completamente nella griglia del complesso all'interno di un cerchio con raggio 2.

Quindi, inizia scansionando ogni punto in quell'area rettangolare. Ogni punto rappresenta un numero complesso (x + yi). Iterate quel numero complesso:

[new value] = [old-value] ^ 2 + [original-value] tenendo traccia di due cose:

1.) il numero di iterazioni

2.) la distanza di [nuovo valore] dall'origine.

Se si raggiunge il numero massimo di iterazioni, il gioco è fatto. Se la distanza dall'origine è maggiore di 2, il gioco è fatto.

Al termine, colora il pixel originale in base al numero di iterazioni eseguite. Quindi passa al pixel successivo.

    public void MBrot()
    {
        float epsilon = 0.0001; // The step size across the X and Y axis
        float x;
        float y;
        int maxIterations = 10; // increasing this will give you a more detailed fractal
        int maxColors = 256; // Change as appropriate for your display.

        Complex Z;
        Complex C;
        int iterations;
        for(x=-2; x<=2; x+= epsilon)
        {
            for(y=-2; y<=2; y+= epsilon)
            {
                iterations = 0;
                C = new Complex(x, y);
                Z = new Complex(0,0);
                while(Complex.Abs(Z) < 2 && iterations < maxIterations)
                {
                    Z = Z*Z + C;
                    iterations++;
                }
                Screen.Plot(x,y, iterations % maxColors); // depending on the number of iterations, color a pixel.
            }
        }
    }

Alcuni dettagli esclusi sono:

1.) Scopri esattamente cos'è il quadrato di un numero complesso e come calcolarlo.

2.) Scopri come tradurre la regione rettangolare (-2,2) in coordinate dello schermo.

Answer 2

Dovresti davvero iniziare con il Mandelbrot set e capire di cosa si tratta realmente.

L'idea alla base è relativamente semplice. Inizi con una funzione di variabile complessa

  

f (z) = z ² + C

dove z è una variabile complessa e C è una costante complessa. Ora lo fai a partire da z = 0, cioè calcoli z ₁ = f (0), z ₂ = f (z ₁ ) , z ₃ = f (z ₂ ) e così via. L'insieme di quelle costanti C per le quali la sequenza z ₁ , z ₂ , z ₃ , ... è delimitata , cioè non va all'infinito, è il set Mandelbrot (il set nero nella figura sulla pagina di Wikipedia).

In pratica, per disegnare il set di Mandelbrot dovresti:

• Scegli un rettangolo nel piano complesso (ad esempio, dal punto -2-2i al punto 2 + 2i).
• Copri il rettangolo con una griglia rettangolare di punti adatta (diciamo, 400x400 punti), che verrà mappata in pixel sul monitor.
• Per ogni punto / pixel, sia C il punto, calcola, diciamo, 20 termini della sequenza iterata corrispondente z ₁ , z ₂ , z ₃ , ... e controlla se "va all'infinito". In pratica puoi verificare, durante l'iterazione, se il valore assoluto di uno dei 20 termini è maggiore di 2 (se uno dei termini lo fa, i termini successivi sono garantiti senza limiti). Se alcuni z_k lo fanno, la sequenza "va all'infinito"; in caso contrario, puoi considerarlo come limitato.
• Se la sequenza corrispondente a un certo punto C è limitata, disegna il pixel corrispondente sull'immagine in nero (perché appartiene all'insieme di Mandelbrot). Altrimenti, disegnalo in un altro colore. Se vuoi divertirti e produrre trame piuttosto carine, disegnalo in diversi colori a seconda della grandezza degli addominali (20 ° termine).

Il fatto sorprendente dei frattali è come possiamo ottenere un set tremendamente complesso (in particolare, la frontiera del set di Mandelbrot) da requisiti facili e apparentemente innocui.

Enjoy!

Answer 3

Se numeri complessi ti fanno venire il mal di testa, esiste una vasta gamma di frattali che possono essere formulati usando un sistema a L. Ciò richiede un paio di livelli che interagiscono, ma ognuno è interessante a sé stante.

Per prima cosa hai bisogno di una tartaruga. Avanti, Indietro, Sinistra, Destra, Penna in su, Penna in giù. Ci sono molte forme divertenti da realizzare con la grafica delle tartarughe usando la geometria delle tartarughe anche senza un sistema a L che la guida. Cerca " LOGO graphics " o " Turtle graphics " ;. Un sistema LOGO è in realtà un Lisp usando un ambiente di programmazione Cambridge Polish . Ma non devi andare così lontano per ottenere delle belle foto usando il concetto di tartaruga.

Quindi è necessario un layer per eseguire un L-system. I sistemi L sono correlati a Post-system e Sistemi semi-Thue , e come virii, si trovano a cavallo del confine di Turing Completezza. Il concetto è riscrittura delle stringhe . Può essere implementato come macro-espansione o set di procedure con controlli extra per limitare la ricorsione. Se si utilizza l'espansione macro (come nell'esempio seguente), sarà comunque necessario un set di procedure per mappare i simboli ai comandi tartaruga e una procedura per iterare attraverso la stringa o l'array per eseguire il programma di tartaruga codificato. Per un set di procedure di ricorsione limitata ( ad es. ), devi incorporare i comandi tartaruga nelle procedure e aggiungere controlli a livello di ricorsione a ciascuna procedura o fattorizzarla in una funzione del gestore.

Ecco un esempio di un albero di Pitagora in postscript che usa l'espansione macro e una serie molto abbreviata di comandi di tartaruga. Per alcuni esempi in python e matematica, vedi il mio code golf challenge .

Answer 4

Esiste un ottimo libro chiamato Chaos and Fractals che ha un semplice codice di esempio alla fine di ogni capitolo che implementa qualche frattale o altro esempio. Molto tempo fa, quando ho letto quel libro, ho convertito ogni programma di esempio (in alcuni dialetti di base) in un'applet Java che gira su una pagina web. Le applet sono qui: http://hewgill.com/chaos-and-fractals/

Uno degli esempi è una semplice implementazione di Mandelbrot.

Answer 5

Un altro eccellente frattale da imparare è il frattale triangolare Sierpinski.

Fondamentalmente, disegna tre angoli di un triangolo (è preferibile un equilatero, ma qualsiasi triangolo funzionerà), quindi inizia un punto P in uno di quegli angoli. Sposta P a metà verso uno dei 3 angoli in modo casuale e traccia un punto lì. Spostare di nuovo P a metà strada verso qualsiasi angolo casuale, disegnare e ripetere.

Penseresti che il movimento casuale creerebbe un risultato casuale, ma in realtà no.

Riferimento: http://en.wikipedia.org/wiki/Sierpinski_triangle

Answer 6

Il triangolo Sierpinski e la curva di Koch sono tipi speciali di frattali di fiamma. I frattali di fiamma sono un tipo molto generalizzato di sistema di funzioni iterate, poiché utilizza funzioni non lineari.

Un algoritmo per IFS: es è il seguente:

Inizia con un punto casuale.

Ripeti più volte quanto segue (almeno un milione, a seconda della dimensione dell'immagine finale):

Applicare una delle N trasformazioni predefinite (trasformazioni di matrice o simili) al punto. Un esempio potrebbe essere quello di moltiplicare ciascuna coordinata per 0,5. Traccia il nuovo punto sullo schermo.

Se il punto è fuori dallo schermo, sceglierne uno a caso all'interno dello schermo.

Se vuoi colori piacevoli, lascia che il colore dipenda dall'ultima trasformazione utilizzata.

Answer 7

Vorrei iniziare con qualcosa di semplice, come un Koch Snowflake . È un semplice processo per prendere una linea e trasformarla, quindi ripetere il processo in modo ricorsivo fino a quando sembra pulito.

Qualcosa di super semplice come prendere 2 punti (una linea) e aggiungere un 3 ° punto (fare un angolo), quindi ripetere ogni nuova sezione creata.

fractal(p0, p1){
    Pmid = midpoint(p0,p1) + moved some distance perpendicular to p0 or p1;
    fractal(p0,Pmid);
    fractal(Pmid, p1);
}

Answer 8

Penso che potresti non vedere i frattali come un algoritmo o qualcosa da programmare. I frattali è un concetto! È un concetto matematico di pattern dettagliati che si ripete.

Quindi puoi creare un frattale in molti modi, usando approcci diversi, come mostrato nell'immagine qui sotto.

Scegli un approccio e poi scopri come implementarlo. Questi quattro esempi sono stati implementati utilizzando Marvin Framework . I codici sorgente sono disponibili qui

Answer 9

Il set mandelbrot viene generato valutando ripetutamente una funzione fino a quando non trabocca (un certo limite definito), quindi controllando quanto tempo ci è voluto per traboccare.

Pseudocodice:

MAX_COUNT = 64 // if we haven't escaped to infinity after 64 iterations, 
               // then we're inside the mandelbrot set!!!

foreach (x-pixel)
  foreach (y-pixel)
    calculate x,y as mathematical coordinates from your pixel coordinates
    value = (x, y)
    count = 0
    while value.absolutevalue < 1 billion and count < MAX_COUNT
        value = value * value + (x, y)
        count = count + 1

    // the following should really be one statement, but I split it for clarity
    if count == MAX_COUNT 
        pixel_at (x-pixel, y-pixel) = BLACK
    else 
        pixel_at (x-pixel, y-pixel) = colors[count] // some color map. 

Note:

valore è un numero complesso. un numero complesso (a + b i) viene quadrato per dare (a a-b * b + 2 * a b i). Dovrai utilizzare un tipo complesso o includere quel calcolo nel tuo ciclo.

Answer 10

Ecco un codice semplice e facile da capire in Java per mandelbrot e altri esempi frattali

http://code.google.com/p/gaima/wiki/VLFImages

Basta scaricare BuildFractal.jar per testarlo in Java ed eseguire con il comando:

java -Xmx1500M -jar BuildFractal.jar 1000 1000 predefinito MANDELBROT

Il codice sorgente è anche gratuito da scaricare / esplorare / modificare / espandere.

Answer 11

Beh, semplice e graficamente accattivante non vanno davvero di pari passo. Se sei seriamente intenzionato a programmare i frattali, ti suggerisco di leggere i sistemi di funzioni iterate e i progressi che sono stati fatti nel renderli.

http://flam3.com/flame_draves.pdf

Answer 12

Le persone sopra stanno usando la ricerca di punti medi per sierpinski e Koch, consiglierei molto di più di copiare forme, ridimensionarle e quindi tradurle per ottenere il "frattale". effetto. Lo pseudo-codice in Java per sierpinski sarebbe simile a questo:

public ShapeObject transform(ShapeObject originalCurve)
    {
        Make a copy of the original curve
        Scale x and y to half of the original
        make a copy of the copied shape, and translate it to the right so it touches the first copied shape
        make a third shape that is a copy of the first copy, and translate it halfway between the first and second shape,and translate it up
        Group the 3 new shapes into one
        return the new shape
    }

Answer 13

A volte programma i frattali per divertimento e come sfida. Puoi trovarli qui . Il codice è scritto in Javascript utilizzando la libreria P5.js e può essere letto direttamente dal codice sorgente HTML.

Per quelli che ho visto gli algoritmi sono abbastanza semplici, basta trovare l'elemento principale e quindi ripeterlo più volte. Lo faccio con funzioni ricorsive, ma può essere fatto diversamente.