Como programar um fractal?

Question

Eu não tenho nenhuma experiência com fractais programação. Claro que eu já vi as famosas imagens de Mandelbrot e tal.

Você pode me fornecer algoritmos simples para fractais.

Linguagem de Programação não importa realmente, mas eu estou mais familiarizado com o ActionScript, C #, Java.

Eu sei que se eu google fractais, recebo um monte de informações (complicado), mas eu gostaria de começar com um algoritmo simples e brincar com ele.

Sugestões para melhorar o algoritmo básico também são bem vindos, como forma de torná-los nessas cores lindas e tal.

Answer 1

A programação do Mandelbrot é fácil.
Meu código quick-n-sujo está abaixo (não garantido para ser livre de bugs, mas um esboço bom).

Aqui está o esquema: Os Mandelbrot-definidos mentiras no Complexo da rede completamente dentro de um círculo com raio de 2.

Então, comece examinando cada ponto nessa área retangular. Cada ponto representa um número complexo (x + Yi). Iterate esse número complexo:

[new value] = [old-value]^2 + [original-value], mantendo o controle de duas coisas:

1.) O número de iterações

2.) A distância do [novo valor] da origem.

Se você atingir o número máximo de iterações, você está feito. Se a distância da origem é maior do que 2, você está feito.

Quando terminar, a cor do pixel originais, dependendo do número de iterações que você fez. Em seguida, passar para o próximo pixel.

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

Alguns detalhes deixado de fora são:

1.) Saiba exatamente o que a Praça de um número complexo é e como calculá-lo.

2.) Descobrir como traduzir o (-2,2) região retangular de coordenadas de tela.

Answer 2

Você deve realmente começar com o Mandelbrot set , e entender o que ele realmente é.

A idéia por trás dele é relativamente simples. Você começa com uma função de variável complexa

f (z) = z ² + C

em que Z é uma variável complexa e C é um complexo constante . Agora você iterar-lo a partir de z = 0, ou seja, você z computação ₁ = f (0), z ₂ = f (z ₁ ) , z ₃ = f (z ₂ ) e assim por diante. O conjunto de constantes aqueles C para que a sequência de z ₁ , z ₂ , z ₃ , ... limitada , ou seja, não ir ao infinito, é o conjunto de Mandelbrot (o conjunto preto na figura na página Wikipedia).

Na prática, para desenhar o Mandelbrot você deve:

• Escolha um retângulo no plano complexo (digamos, do ponto -2-2i ao ponto 2 + 2-I).
• Cubra o retângulo com uma grade retangular adequado de pontos (digamos, 400x400 pontos), que será mapeado para pixels em seu monitor.
• Para cada ponto / pixel, seja C que ponto, computação, digamos, 20 termos da correspondente iterado sequência z ₁ , z ₂ , z ₃ , ... e verificar se ele "vai para o infinito". Na prática, você pode verificar, durante a iteração, se o valor absoluto de um dos 20 termos é maior do que 2 (se um dos termos faz, os termos seguintes são garantidos para ser ilimitada). Se algum z_k faz, a seqüência "vai para o infinito"; caso contrário, você pode considerá-lo como limitado.
• Se a sequência correspondente a um determinado ponto C é delimitada, desenhar o pixel correspondente na imagem em preto (por ele pertence ao conjunto de Julia). Caso contrário, desenhá-lo em outra cor. Se você quer se divertir e produzir gráficos bonitos, desenhá-lo em cores diferentes, dependendo da magnitude do abs (20 prazo).

O fato surpreendente sobre fractais é como podemos obter um conjunto extremamente complexo (em particular, a fronteira do conjunto de Mandelbrot) de requisitos fáceis e aparentemente inócuas.

Aproveite!

Answer 3

Se os números complexos dar-lhe uma dor de cabeça, há uma ampla gama de fractais que podem ser formuladas utilizando uma L-sistema. Isso requer um par de camadas que interagem, mas cada um é interessante nele próprio direito.

Primeiro você precisa de uma tartaruga. Frente, para trás, esquerda, direita, Pen-up, Pen-down. Há muitas formas divertidas de ser feitas com tartaruga gráficos usando geometria tartaruga mesmo sem uma L-sistema de conduzi-lo. Procurar "Logotipo gráficos" ou "gráficos tartaruga". A LOGO completo é na verdade um Lisp ambiente de programação usando um unparenthesized Cambridge Polish sintaxe. Mas você não tem que ir quase tão longe para obter algumas imagens bonitas usando o conceito de tartaruga.

Em seguida, você precisa de uma camada para executar uma L-sistema. L-sistemas estão relacionados com a Pós-sistemas e sistemas Semi-Thue , e como virii, eles situam na fronteira de Turing completude. O conceito é -string reescrever . Ele pode ser implementado como uma macro-expansão ou um conjunto procedimento com controles extras para limitar a recursividade. Se estiver usando macro-expansão (como no exemplo abaixo), você ainda vai precisar de um conjunto de procedimento para mapear símbolos para os comandos de tartaruga e um procedimento para percorrer a string ou matriz para executar o programa tartaruga codificado. Para um procedimento set-recursão delimitada ( por exemplo. ), você incorporar os comandos de tartaruga nos procedimentos e tanto adicionar verificações de nível de recursão para cada procedimento ou fator-lo para uma função de manipulador.

Aqui está um exemplo de árvore de uma Pitágoras em PostScript usando macro-expansão e um conjunto muito abreviada de comandos de tartaruga. Para alguns exemplos em Python e mathematica, ver o meu código desafio de golfe .

Answer 4

Há um grande livro chamado Caos e Fractals que tem código de exemplo simples no final de cada capítulo que implementa algum exemplo fractal ou outro. Há muito tempo atrás, quando eu li esse livro, eu converti cada programa de amostra (em algum dialeto Basic) em um applet Java que roda em uma página web. Os applets está aqui: http://hewgill.com/chaos-and-fractals/

Uma das amostras é uma implementação simples de Mandelbrot.

Answer 5

Outra excelente fractal para aprender é o Triângulo de Sierpinski Fractal.

Basicamente, desenhar três cantos de um triângulo equilátero (um é o preferido, mas qualquer triângulo funcionará), em seguida, iniciar um ponto P a uma desses cantos. P mover a meio caminho para qualquer das 3 cantos de forma aleatória, e desenhar um ponto lá. Novamente mover P no meio do caminho em direção a qualquer canto aleatório, desenhar, e repita.

Você acha que o movimento aleatório criaria um resultado aleatório, mas realmente não faz.

Referência: http://en.wikipedia.org/wiki/Sierpinski_triangle

Answer 6

O triângulo de Sierpinski e a curva de Koch são tipos especiais de fractals da chama. fractais de chama são um tipo muito generalizada do sistema iterado da função, uma vez que utiliza funções não lineares.

Um algoritmo para IFS: es são os seguintes:

Start with a random point.

Repita as seguintes muitas vezes (um milhão, pelo menos, dependendo do tamanho da imagem final):

Apply one of N predefined transformations (matrix transformations or similar) to the point. An example would be that multiply each coordinate with 0.5. Plot the new point on the screen.

Se o ponto estiver fora da tela, escolher aleatoriamente um novo dentro da tela em seu lugar.

Se você quiser cores agradáveis, deixe a cor dependem da última transformação utilizado.

Answer 7

Gostaria de começar com algo simples, como um Koch Snowflake . É um processo simples de tomar uma linha e transformando-a, em seguida, repetindo o processo recursivamente até que parece limpo-o.

Algo super simples como tomar 2 pontos (uma linha) e adicionando um terceiro ponto (fazendo um canto), em seguida, repetindo em cada nova seção que é criado.

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

Answer 8

Eu acho que você não pode ver fractais como um algoritmo ou algo para programa. Fractals é um conceito! É um conceito matemático de padrão detalhado repetir-se.

Portanto, você pode criar um fractal de muitas maneiras, usando diferentes abordagens, como mostrado na imagem abaixo.

Escolha uma abordagem e, em seguida, investigar como implementá-lo. Estes quatro exemplos foram implementados usando Marvin Framework . Os códigos-fonte estão disponíveis aqui

Answer 9

O conjunto de Mandelbrot é gerado através da avaliação repetidamente uma função até que transborde (algum limite definido), em seguida, verificar quanto tempo levou você a transbordar.

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:

valor é um número complexo. um número complexo (a + b i) é quadrado para dar (a a-b * b + 2 * a b i). Você terá que usar um tipo complexo, ou incluir esse cálculo no seu loop.

Answer 10

Aqui está uma simples e fácil de entender o código em Java para Mandelbrot e outros exemplos fractais

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

Basta baixar o BuildFractal.jar para testá-lo em Java e executado com o comando:

java -jar -Xmx1500M BuildFractal.jar 1000 1000 Mandelbrot padrão

O código fonte também está livre para download / explorar / editar / expandir.

Answer 11

Bem, simples e graficamente atraente realmente não andam de mãos dadas. Se você é sério sobre fractais programação, sugiro ler-se sobre sistemas de funções iterativas e os avanços que têm sido feitas em tornando-os.

http://flam3.com/flame_draves.pdf

Answer 12

Pessoas acima estão usando encontrar pontos médios para sierpinski e Koch, eu muito mais recomendável copiar formas, escalando-os, em seguida, traduzi-las para alcançar o efeito "fractal". Pseudo-código em Java para sierpinski seria algo parecido com isto:

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

Às vezes eu programar fractais para diversão e como um desafio. Você pode encontrá-los aqui . O código é escrito em JavaScript usando a biblioteca P5.js e podem ser lidos diretamente a partir do código-fonte HTML.

Para aqueles que tenho visto os algoritmos são bastante simples, basta encontrar o elemento central e, em seguida, repeti-la mais e mais. Eu faço isso com funções recursivas, mas pode ser feito de forma diferente.