globals [ iteracao comprimento cor ]

to preparar
    ca
    set iteracao 0
    set cor cor-inicial
    cct 1 [
        set size 10
        set color cor-inicial
        if not mostra-tartarugas? [ ht ]
    ]
    if fractal = "arvore de Sierpinski" [ prepara-arvore-de-sierpinski ]
    if fractal = "quadrado de Sierpinski" [ prepara-quadrado-de-sierpinski ]
    if fractal = "tapete de Sierpinski" [ prepara-tapete-de-sierpinki ]    
    if fractal = "floco de neve" [ prepara-floco-de-neve ]
end

to desenhar
    if comprimento < 1 [ user-message "Ultrapassou o limite de resolucao do ecran." ]
    if fractal = "arvore de Sierpinski" [ desenha-arvore-de-sierpinski ]
    if fractal = "quadrado de Sierpinski" [ desenha-quadrado-de-sierpinski ]
    if fractal = "floco de neve" [ desenha-floco-de-neve ]
    if fractal = "tapete de Sierpinski" [ desenha-tapete-de-sierpinki ]
    set iteracao iteracao + 1
    muda-cor
end

to prepara-arvore-de-sierpinski
    ask turtles [ 
        setxy 0 -70 
        pd
    ]
    set comprimento 140
end

to prepara-quadrado-de-sierpinski
    ask turtles [ 
        setxy 0 0
        pd
    ]
    set comprimento 128
end

to prepara-tapete-de-sierpinki
    set comprimento 243 
    ask patches with [ abs pxcor <= 121 and abs pycor <= 121 ][ set pcolor blue ]
    set comprimento comprimento / 3
end

to prepara-floco-de-neve
    set comprimento 420
    ask turtles [ 
        setxy -121 -210
        pd
        repeat 3 [
            hatch 1 []
            fd comprimento
            rt 120
        ]
        die
    ]
    muda-cor
    set comprimento comprimento / 3
end

to desenha-arvore-de-sierpinski
    locals [ angulo ]
    ask turtles [
        set angulo 0
        hatch 3 [
            set heading angulo
            fd comprimento
            set angulo angulo + 120
        ]
        die
    ]
    set comprimento comprimento / 2
end

to desenha-floco-de-neve 
    ask turtles [
        repeat 2 [
            hatch 1 []
            fd comprimento
            lt 60
            hatch 1 []
            fd comprimento
            rt 120
        ]
        die
    ]
    set comprimento comprimento / 3
end

to desenha-quadrado-de-sierpinski
    locals [ angulo ]
    ask turtles [
        set angulo 0
        hatch 8 [
            set heading angulo
            salta (comprimento / 2) * calcula-factor heading        
            fd (comprimento / 3 ) * calcula-factor heading
            salta (comprimento / 6) * calcula-factor heading
            set angulo angulo + 45
        ]
        die
    ]
    set comprimento comprimento / 3
end

to desenha-tapete-de-sierpinki
    locals [ lado angulo x y ]
    set lado (comprimento - 1) / 2
    ask turtles [
        without-interruption [
            set angulo 0
            set x xcor
            set y ycor
            hatch 8 [
                set heading angulo
                fd comprimento * calcula-factor angulo
                setxy round xcor round ycor
                set angulo angulo + 45
            ]
            ask patches in-radius (ceiling (lado * sqrt 2)) [
                if abs (pxcor - x) <= lado and abs (pycor - y) <= lado [
                    set pcolor black
                ]
            ]
            die
        ] 
    ]
    set comprimento comprimento / 3
end

to-report calcula-factor [ angulo ]
    ifelse (angulo / 45) mod 2 = 0 [ report 1 ][ report sqrt 2 ] 
end

to salta [ distancia ]
    pu
    fd distancia
    pd
end

to muda-cor
    set cor cor + incremento
    if cor = black [ set cor cor + incremento ]
    ask turtles [ set color cor ]
end
@#$#@#$#@
GRAPHICS-WINDOW
151
10
675
555
256
256
1.002
1
10
1
1
1
0
1
1
1
-256
256
-256
256

CC-WINDOW
5
569
684
664
Command Center
0

BUTTON
0
52
143
85
Desenhar uma iteração
desenhar
NIL
1
T
OBSERVER
T
NIL

SLIDER
0
274
143
307
incremento
incremento
0
100
10
1
1
NIL

SLIDER
0
232
143
265
cor-inicial
cor-inicial
0
140
15
1
1
NIL

BUTTON
0
94
143
127
Desenhar
desenhar
T
1
T
OBSERVER
T
NIL

MONITOR
59
317
143
366
Nº Tartarugas
count turtles
10
1

MONITOR
0
317
51
366
NIL
iteracao
0
1

CHOOSER
0
136
143
181
fractal
fractal
"arvore de Sierpinski" "floco de neve" "quadrado de Sierpinski" "tapete de Sierpinski"
0

BUTTON
0
10
143
43
NIL
preparar
NIL
1
T
OBSERVER
T
NIL

SWITCH
0
191
143
224
mostra-tartarugas?
mostra-tartarugas?
1
1
-1000

@#$#@#$#@
INTRODUÇÃO
-----------

Alguns fractais, como os exemplos deste programa, possuem auto-semelhança exacta, isto é, têm sempre o mesmo aspecto visual independentemente da escala a que os observamos, porque o todo é exactamente igual à ampliação de uma das partes. 
Esta propriedade resulta do facto de serem construídos pela iteração 'ad infinitum' 
da mesma regra de construção.

Muitas formas na natureza são aproximadas por esta geometria. 
No entanto, os fractais apresentados neste programa não foram inventados para simular as propriedades de padrões naturais, mas sim para mostrar que a matemática continha mais objectos para além das curvas e superfícies regulares da geometria tradicional. 

Considere o exemplo da famosa curva de Koch, criado em 1904 pelo matemático sueco Helge von Koch. Começa-se com um segmento de recta. Ao objecto inicial da construção chama-se "iniciador". De seguida divide-se o segmento inicial em três segmentos iguais. Depois disto substitui-se o terço do meio por um triângulo equilátero tirando-lhe a sua base. Neste momento completou-se a construção da unidade fundamental, o "gerador". 
A iteração deste processo consiste em aplicar a mesma regra a cada um dos
segmentos de recta que resultam da iterada anterior, como se ilustra na figura.
A curva de Koch é o objecto que se obtem no limite em que o número de iterações tende para infinito.


|     ________________________     Passo 0: "Iniciador"
|  
|                /\  
|               /  \ 
|              /    \ 
|             /      \
|     _______/        \_______     Passo 1: "Gerador" 
|  
|                /\  
|             __/  \__ 
|             \      /
|             /      \   
|     ___/\__/        \__/\___     Passo 2
|
|               ...

A auto-semelhança é um ingredientes do processo de construção. Cada segmento de recta contido na iterada k está reduzido por um factor de 3 em relação aos segmentos de recta que compõem a iterada anterior, e cada um dos quatro troços que compõem a iterada k é uma cópia, reduzida por um factor 3, de toda a estrutura da iterada imediatamente anterior. 

Por isso, o objecto que resulta da passagem ao limite deste processo recursivo é exactamente auto-semelhante, é igual a uma cópia ampliada dos elementos que o constituem. Este objecto exótico tem o nome de curva, mas é uma curva que não contem nenhum segmento de recta e não pode ser diferenciada em nenhum dos seus pontos (é uma curva em que todos os pontos são "bicos").


UTILIZAÇÃO
-------------
O programa permite seleccionar a construção de diferentes fractais geométricos.
Por exemplo, para gerar a Árvore de Sierpinski, começa-se por escolher
um ponto no plano e desenha-se três segmentos de recta desde esse ponto até aos vértices de um triângulo equilátero centrado no ponto inicial.

A segunda iteração do processo obtem-se aplicando a mesma operação sobre 
os vértices do triângulo considerados como novos pontos iniciais, e tomando segmentos
de recta de comprimento metade dos da iteração anterior. A Árvore de Sierpinski
é o fractal que resulta de iterar indefinidamente esta regra de construção.  

Pode ver este procedimento posto em prática seleccionando a Árvore de Sierpinski e pressionando vezes sucessivas o botão "Desenhar uma iteracao". Pressionando este botão executa-se uma só vez a regra usada para a construção do fractal seleccionado.  
O botão "Desenhar" ("forever button") executa exactamente o mesmo procedimento que "Desenhar uma iteracao", mas executa-o até o utilizador voltar a pressioná-lo.

O botão quadrado de Sierpinski utiliza uma regra similar a esta com outra simetria.
Premindo o botão Quadrado de Sierpinski 2 segue-se um esquema de desenho do fractal ligeiramente diferente do anterior. A ideia é dividir o quadrado inicial em nove quadrados iguais, retirar o do meio e aplicar indefinidamente este procedimentos ao quadrados restantes ao fim de cada iteração. Este é também um dos métodos de obtenção do Triângulo de Sierpinski. Finalmente, o programa permite ainda gerar a ilha de Koch, uma variante da curva de Koch. 

O utilizador pode modificar o aspecto visual do seu fractal escolhendo a cor da primeira turtle criada ("cor-inic"). As turtles das gerações seguintes terão uma cor que corresponde à cor da sua "progenitora" incrementada de "cor-incremento" (ver representação numérica das cores no manual do utilizador). 

Desta maneira, o código de cores permite visualizar o resultado das sucessivas iterações da regra de construção.

A interface apresenta ainda o botão "Exportar Mundo", que serve para armazenar num ficheiro o padrão gerado na janela. Utilizaremos esta funcionalidade para importar as imagens dos fractais geométricos para o programa de cálculo da dimensão de contagem de caixas.

OBSERVAÇÕES E QUESTÕES
-----------------------

1) Para se criar o Quadrado de Sierpinski o método utilizado foi o mesmo que para a Árvore, só que a regra mudou. Qual será a regra usada?

2) Qual é o limite a partir do qual a figura não se altera com sucessivas iterações da regra? Faça uma estimativa do número de iterações correspondente.

3) Note a auto-semelhança dos objectos a cada iteração. Iterando um número finito de vezes, notar-se-ía alguma diferença entre uma ampliação de uma parte da figura e
toda a figura?

4) Quais são as diferenças entre o Triângulo e a Árvore de Sierpinski e entre o Quadrado de Sierpinski 2 e o Quadrado de Sierpinski ?

5) Note que o número de turtles em cada iteração vai sempre aumentando de um factor
constante. Determine esse factor e preveja o o número de turtles numa iterada qualquer n. Relacione este cálculo com a taxa de aumento do aumento exponencial do tempo de desenho com n.  


VARIANTES E EXTENSÕES
---------------------

Experimente fazer os seus próprios fractais!
Para isso crie um botão (análogo aos existentes) que inicializa as variáveis necessárias para desenhar o seu fractal. De seguinda escreva uma função onde estarão as regras para a construção do seu fractal e coloque-a no procedimento Desenhar.
Construa as suas regras com as funções já criadas ou com outras que crie (p.e. frente 5 dir 90 salta 3 m). Basta seguir o exemplo dado pelo próprio programa.

Em baixo está a regra que cria o fractal Recobrimento Universal da Figura Oito.
Experimente esta! 
|                   .               Passo 0

|
|                   |
|                   |
|                   |
|            ______________         Passo 1
|                   |
|                   |
|                   |

|                   |
|                 __|__
|                   |
|                   |
|           __|___________|__       Passo 2
|             |     |     |
|                   |
|                 __|__ 
|                   |


Procure outros fractais e tente representá-los usando as regras deste programa ou outras. 


CRÉDITOS E REFERÊNCIAS
----------------------

Para obter mais informações sobre esta temática pode consultar:
 
- http://classes.yale.edu/Fractals/

Algumas partes deste código foram adaptadas do programa "L-System Fractals" presente na biblioteca ("Models Library") anexa ao NetLogo 2.0.1. 
-  Wilensky, U. (2001).  NetLogo L-System Fractals model.
    http://ccl.northwestern.edu/netlogo/models/L-SystemFractals. Center for Connected
    Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

link
true
0
Line -7500403 true 150 0 150 300

link direction
true
0
Line -7500403 true 150 150 30 225
Line -7500403 true 150 150 270 225

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
true
0
Polygon -7500403 true true 45 255 255 255 255 45 45 45

circle
true
0
Circle -7500403 true true 35 35 230

line
true
0
Line -7500403 true 150 0 150 295

person
false
0
Circle -7500403 true true 155 20 63
Rectangle -7500403 true true 158 79 217 164
Polygon -7500403 true true 158 81 110 129 131 143 158 109 165 110
Polygon -7500403 true true 216 83 267 123 248 143 215 107
Polygon -7500403 true true 167 163 145 234 183 234 183 163
Polygon -7500403 true true 195 163 195 233 227 233 206 159

spacecraft
true
0
Polygon -7500403 true true 150 0 180 135 255 255 225 240 150 180 75 240 45 255 120 135

thin-arrow
true
0
Polygon -7500403 true true 150 0 0 150 120 150 120 293 180 293 180 150 300 150

truck-down
false
0
Polygon -7500403 true true 225 30 225 270 120 270 105 210 60 180 45 30 105 60 105 30
Polygon -8630108 true false 195 75 195 120 240 120 240 75
Polygon -8630108 true false 195 225 195 180 240 180 240 225

truck-left
false
0
Polygon -7500403 true true 120 135 225 135 225 210 75 210 75 165 105 165
Polygon -8630108 true false 90 210 105 225 120 210
Polygon -8630108 true false 180 210 195 225 210 210

truck-right
false
0
Polygon -7500403 true true 180 135 75 135 75 210 225 210 225 165 195 165
Polygon -8630108 true false 210 210 195 225 180 210
Polygon -8630108 true false 120 210 105 225 90 210

turtle
true
0
Polygon -7500403 true true 138 75 162 75 165 105 225 105 225 142 195 135 195 187 225 195 225 225 195 217 195 202 105 202 105 217 75 225 75 195 105 187 105 135 75 142 75 105 135 105

@#$#@#$#@
NetLogo 3.1.3
@#$#@#$#@
ballSetup
repeat 14 [ iterate ]
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@