¿Cómo programar un fractal?

Question

No tengo ninguna experiencia con la programación de fractales. Por supuesto, he visto las famosas imágenes de Mandelbrot y demás.

¿Puede proporcionarme algoritmos simples para fractales?

El lenguaje de programación no importa realmente, pero estoy más familiarizado con actionscript, C #, Java.

Sé que si busco fractales en Google, obtengo mucha información (complicada) pero me gustaría comenzar con un algoritmo simple y jugar con él.

Las sugerencias para mejorar el algoritmo básico también son bienvenidas, como cómo hacerlas en esos hermosos colores y demás.

Answer 1

Programar el Mandelbrot es fácil.
Mi código rápido y sucio está debajo (no se garantiza que esté libre de errores, pero es un buen resumen).

Aquí está el esquema: El conjunto de Mandelbrot se encuentra en la cuadrícula compleja completamente dentro de un círculo con radio 2.

Entonces, comience escaneando cada punto en esa área rectangular. Cada punto representa un número complejo (x + yi). Iterar ese número complejo:

[nuevo valor] = [valor antiguo] ^ 2 + [valor original] mientras se realiza un seguimiento de dos cosas:

1.) el número de iteraciones

2.) la distancia de [new-value] desde el origen.

Si alcanza el número máximo de iteraciones, ya está. Si la distancia desde el origen es mayor que 2, ya está.

Cuando termine, coloree el píxel original según la cantidad de iteraciones que haya realizado. Luego pase al siguiente píxel.

    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.
            }
        }
    }

Algunos detalles omitidos son:

1.) Aprenda exactamente cuál es el cuadrado de un número complejo y cómo calcularlo.

2.) Descubre cómo traducir la región rectangular (-2,2) a las coordenadas de la pantalla.

Answer 2

Debería comenzar con el conjunto de Mandelbrot , y comprender qué es realmente.

La idea detrás de esto es relativamente simple. Empiezas con una función de variable compleja

  

f (z) = z ² + C

donde z es una variable compleja y C es una constante compleja. Ahora lo itera a partir de z = 0, es decir, calcula z ₁ = f (0), z ₂ = f (z ₁ ) , z ₃ = f (z ₂ ) y así sucesivamente. El conjunto de esas constantes C para las cuales la secuencia z ₁ , z ₂ , z ₃ , ... está limitada , es decir, no llega al infinito, es el conjunto de Mandelbrot (el conjunto negro en la figura de la página de Wikipedia).

En la práctica, para dibujar el conjunto de Mandelbrot debes:

• Elija un rectángulo en el plano complejo (por ejemplo, desde el punto -2-2i hasta el punto 2 + 2i).
• Cubra el rectángulo con una cuadrícula de puntos rectangular adecuada (por ejemplo, 400x400 puntos), que se asignará a píxeles en su monitor.
• Para cada punto / píxel, sea C ese punto, calcule, digamos, 20 términos de la secuencia iterada correspondiente z ₁ , z ₂ , z ₃ , ... y compruebe si " va al infinito " ;. En la práctica, puede verificar, mientras itera, si el valor absoluto de uno de los 20 términos es mayor que 2 (si uno de los términos lo hace, se garantiza que los términos subsiguientes serán ilimitados). Si algo de z_k lo hace, la secuencia '' va al infinito ''; de lo contrario, puede considerarlo como limitado.
• Si la secuencia correspondiente a un cierto punto C está delimitada, dibuje el píxel correspondiente en la imagen en negro (porque pertenece al conjunto de Mandelbrot). De lo contrario, dibuja en otro color. Si quieres divertirte y producir bonitas parcelas, dibuja en diferentes colores dependiendo de la magnitud de los abdominales (vigésimo término).

El hecho sorprendente sobre los fractales es cómo podemos obtener un conjunto tremendamente complejo (en particular, la frontera del conjunto de Mandelbrot) a partir de requisitos fáciles y aparentemente inocuos.

¡Disfruta!

Answer 3

Si los números complejos le causan dolor de cabeza, existe una amplia gama de fractales que se pueden formular utilizando un sistema L. Esto requiere un par de capas interactuando, pero cada una es interesante por derecho propio.

Primero necesitas una tortuga. Adelante, Atrás, Izquierda, Derecha, Pen-up, Pen-down. Hay muchas formas divertidas que se pueden hacer con gráficos de tortuga usando geometría de tortuga, incluso sin un sistema L que lo maneje. Busque '' LOGO graphics '' o "Gráficos de tortuga". Un completo LOGO es de hecho un entorno de programación Lisp utilizando un sintaxis del polaco de Cambridge . Pero no tiene que ir tan lejos para obtener algunas fotos bonitas utilizando el concepto de tortuga.

Entonces necesita una capa para ejecutar un sistema L. Los sistemas L están relacionados con Post-systems y Sistemas Semi-Thue , y al igual que virii, se extienden a horcajadas en el límite de la integridad de Turing. El concepto es reescritura de cadenas . Se puede implementar como una macroexpansión o un conjunto de procedimientos con controles adicionales para limitar la recursividad. Si usa macroexpansión (como en el ejemplo a continuación), aún necesitará un procedimiento establecido para asignar símbolos a los comandos de tortuga y un procedimiento para recorrer la cadena o matriz para ejecutar el programa de tortuga codificado. Para un conjunto de procedimientos de recursión limitada ( eg. ), incrusta los comandos de tortuga en los procedimientos y agregue comprobaciones de nivel de recursión a cada procedimiento o factorícelo en una función de controlador.

Aquí hay un ejemplo de un árbol de Pitágoras en postscript usando macroexpansión y un conjunto muy abreviado de comandos de tortuga. Para ver algunos ejemplos en Python y Mathica, consulte mi desafío de golf de código .

Answer 4

Hay un gran libro llamado Chaos and Fractals que tiene un código de ejemplo simple al final de cada capítulo que implementa algún fractal u otro ejemplo. Hace mucho tiempo, cuando leí ese libro, convertí cada programa de muestra (en algún dialecto básico) en un applet de Java que se ejecuta en una página web. Los applets están aquí: http://hewgill.com/chaos-and-fractals/

Una de las muestras es una implementación simple de Mandelbrot.

Answer 5

Otro excelente fractal para aprender es el Fractal Triángulo de Sierpinski.

Básicamente, dibuja tres esquinas de un triángulo (se prefiere un equilátero, pero cualquier triángulo funcionará), luego comienza un punto P en una de esas esquinas. Mueve P hasta la mitad de cualquiera de las 3 esquinas al azar, y dibuja un punto allí. Nuevamente mueva P a mitad de camino hacia cualquier esquina aleatoria, dibuje y repita.

Pensarías que el movimiento aleatorio crearía un resultado aleatorio, pero realmente no lo hace.

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

Answer 6

El triángulo de Sierpinski y la curva de Koch son tipos especiales de fractales de llama. Los fractales de llama son un tipo muy generalizado de sistema de funciones iteradas, ya que utiliza funciones no lineales.

Un algoritmo para IFS: es es el siguiente:

Comience con un punto aleatorio.

Repita lo siguiente muchas veces (al menos un millón, según el tamaño de la imagen final):

Aplique una de las N transformaciones predefinidas (transformaciones matriciales o similares) al punto. Un ejemplo sería que multiplique cada coordenada con 0.5. Trace el nuevo punto en la pantalla.

Si el punto está fuera de la pantalla, elija aleatoriamente uno nuevo dentro de la pantalla.

Si desea colores agradables, deje que el color dependa de la última transformación utilizada.

Answer 7

Comenzaría con algo simple, como un Koch Snowflake . Es un proceso simple de tomar una línea y transformarla, luego repetir el proceso recursivamente hasta que se vea ordenado.

Algo súper simple como tomar 2 puntos (una línea) y agregar un tercer punto (hacer una esquina), luego repetir en cada nueva sección que se crea.

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

Answer 8

Creo que es posible que no veas los fractales como un algoritmo o algo para programar. Fractales es un concepto! Es un concepto matemático de patrón detallado que se repite.

Por lo tanto, puede crear un fractal de muchas maneras, utilizando diferentes enfoques, como se muestra en la imagen a continuación.

Elija un enfoque y luego investigue cómo implementarlo. Estos cuatro ejemplos se implementaron usando Marvin Framework . Los códigos fuente están disponibles aquí

Answer 9

El conjunto de mandelbrot se genera evaluando repetidamente una función hasta que se desborda (algún límite definido) y luego verifica cuánto tiempo tardó en desbordarse.

Pseudocódigo:

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. 

Notas:

El valor

es un número complejo. un número complejo (a + b i) se eleva al cuadrado para dar (a a-b * b + 2 * a b i). Tendrá que usar un tipo complejo o incluir ese cálculo en su ciclo.

Answer 10

Aquí hay un código simple y fácil de entender en Java para mandelbrot y otros ejemplos fractales

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

Simplemente descargue BuildFractal.jar para probarlo en Java y ejecutar con el comando:

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

El código fuente también se puede descargar / explorar / editar / expandir gratuitamente.

Answer 11

Bueno, simple y gráficamente atractivo realmente no van de la mano. Si te tomas en serio la programación de fractales, te sugiero que leas sobre los sistemas de funciones iteradas y los avances que se han hecho para representarlos.

http://flam3.com/flame_draves.pdf

Answer 12

Las personas de arriba están utilizando puntos medios de búsqueda para sierpinski y Koch. Recomiendo mucho más copiar formas, escalarlas y luego traducirlas para lograr el "fractal". efecto. El pseudocódigo en Java para sierpinski se vería así:

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 veces programo fractales por diversión y como desafío. Puede encontrarlos aquí . El código está escrito en Javascript usando la biblioteca P5.js y puede leerse directamente desde el código fuente HTML.

Para aquellos que he visto, los algoritmos son bastante simples, solo encuentra el elemento central y luego repítelo una y otra vez. Lo hago con funciones recursivas, pero se puede hacer de manera diferente.