turtles-own  ;variável das turtles que indica se cada uma foi ou não criada na iteração corrente
[ nova? ]

globals
[
  comp                 ;comprimento
  Qsierpinski?         ;
  Qsierpinski2?        ; 
  Asierpinski?         ;
  koch?                ;;indicam a opção do utilizador quanto ao fractal a desenhar
  primeira-passagem?
  N                    ; variável auxiliar (indica o número de patches de um lado do quadrado) 
  cor                  ; mantem a cor da última iteração
  iteracao
]

to desenhar           ;procedimento que é executado sempre que se pressiona Desenhar uma iteração ou Desenhar
  if Asierpinski? = 0 and koch? = 0 and Qsierpinski? = 0 and Qsierpinski2? = 0
    [ user-message "Escolha um fractal!" stop ]
    
  set iteracao iteracao + 1
  ifelse (Asierpinski?)
    [ ArvoreSierpinski ]
    [
     ifelse (koch?)
       [ IlhaKoch ]
       [
        ifelse (Qsierpinski?) 
          [ QuadradoSierpinski ]
          [ 
           if 1 > N [ user-message "Atingiu a resolução máxima" stop ] ;Se N for menor que 1 atingiu-se a resolução máxima deste programa 
           QuadradoSierpinski2
          ] 
       ]
    ]
end

;para cada turtle antiga, na iteração corrente, cria uma turtle nova e
;inicializa a sua variável nova? com o valor lógico verdadeiro
to t
  ask turtles with [ not nova? ]
    [
      set color cor
      hatch 1 [ set nova? true ]
    ]
end

;muda a cor das tartarugas de iteração em iteração, de acordo
;com o incremento
to muda_cor
  set cor cor + cor-incremento
  if cor = black
    [ set cor cor + cor-incremento ]
  ask turtles with [ nova? ]
    [ set color cor ]
end

;roda cada turtle com nova? = falso (isto é que não foi criada durante a presente iteração) 
;gr graus à direita
to dir [ graus ]
  ask turtles with [ not nova? ] [ rt graus ]
end

;cada turtle com nova? = falso vira gr graus à esquerda
to esq [ graus ]
  ask turtles with [ not nova? ] [ lt graus ]
end

;move todas as turtles com nova? = falso em frente o numero de passos
;dado no argumento
to frente [ passos ]
  ask turtles with [ not nova? ] [ fd passos ]
end

;move todas as turtles com nova? = falso em frente o numero de passos
;dado no argumento mas sem pintar os patches por debaixo
to salta [ passos ]
  ask turtles with [ not nova? ] [ pu fd passos pd ]
end

;mata todas as turtles não novas (i.e. com a variável nova? igual a falso)
to m
  ask turtles with [ not nova? ] [ die ]
end

;exporta o mundo (escreve o valor de todas as variáveis)
;para um ficheiro de nome nomeficheiro 
to exportarmundo
 locals [nomeficheiro ax ay]

 ask turtles [ die ]
 
 set nomeficheiro user-choose-new-file

 if file-exists? nomeficheiro [
   file-delete nomeficheiro
 ]
 
 file-open nomeficheiro
 file-print screen-size-x
 file-print screen-size-y
 
 show "sx: "+ screen-size-x + "  sy: "+ screen-size-y
; show "ex: "+ screen-edge-x + "  ey: "+ screen-edge-y
 set ay (- screen-edge-y)
 repeat screen-size-y
 [
   set ax (- screen-edge-x)
   repeat screen-size-x
   [
     ask patch ax ay [
       file-print pcolor
     ]
     set ax ax + 1
   ]
   set ay ay + 1
 ]
 file-close
end

to AsierpinskiSetup  ;inicializa as variáveis necessárias para seguidamente se efectuar o desenho da Árvore de Sierpinski 
  ca
  crt 1
  set iteracao 0
  set cor cor-inic
  ask turtles
  [
    set shape "line"
    set color cor-inic
    setxy 0 -70
    set heading 0
    pd
  ]
  set comp 140
  set Asierpinski? true   ;indica a opção do utilizador quanto ao objecto a desenhar
  set koch? false
  set Qsierpinski? false
  set Qsierpinski2? false
end

to ArvoreSierpinski
  ask turtles [ set nova? false pd ] ;a cada nova iteração, as turtles existentes passam a antigas para essa iteração
  repeat 3     ;regra de construção
    [
      frente comp
      t
      dir 180
      salta comp
      dir 180
      dir 120
    ]
  muda_cor
  set comp (comp / 2)
  m
end

to kochSetup   ;inicializa as variáveis necessárias para seguidamente se efectuar o desenho da Ilha de Koch 
  ca
  crt 1
  set iteracao 0
  set cor cor-inic
  ask turtles
    [
      set shape "line"
      set color cor-inic
      setxy -121 -210
      set heading 0
      pd
    ]
  set comp 140
  set Asierpinski? false
  set koch? true
  set Qsierpinski? false
  set Qsierpinski2? false
  set primeira-passagem? true
end

to IlhaKoch
  ask turtles [ set nova? false pd ] ;a cada nova iteração, as turtles existentes passam a antigas para essa iteração
  ifelse (primeira-passagem?)
    [
      set primeira-passagem? false
      repeat 3  ;na primeira passagem por este procedimento estas regras são executadas 3 vezes para que se obtenha a forma de ilha
        [
          t frente comp esq 60 t frente comp dir 120 t frente comp esq 60 t frente comp dir 120
        ]
    ]
    [  ;note que estas regras são as mesmas que as anteriores, só que agora só são executadas uma vez
      t frente comp esq 60 t frente comp dir 120 t frente comp esq 60 t frente comp dir 120
    ]
  muda_cor
  set comp (comp / 3)
  m
end

to QsierpinskiSetup ;inicializa as variáveis necessárias para seguidamente se efectuar o desenho do quadrado de Sierpinski
  ca
  crt 1
  set iteracao 0
  set cor cor-inic
  ask turtles
    [
      set shape "line"
      set color cor-inic
      setxy 0 0
      set heading 0
      pd
    ]
  set comp 128
  set Asierpinski? false  ;indica a opção do utilizador quanto ao objecto a desenhar
  set koch? false
  set Qsierpinski? true
  set Qsierpinski2? false
end

to QuadradoSierpinski
  ask turtles
    [ set nova? false pd ]
  ask turtles[ set heading 0 ]     
  repeat 4   ;regra de construção. Para se perceber como a regra foi refinada apresenta-se 
    [        ;a versão antiga, está comentada e apresenta-se a versão actual.
             ;Experimente a descomentar essas duas linhas e a comentar as seguintes indicadas por ; à direita 
      ;frente comp        
      salta comp / 2   ; 
      frente comp / 27 ; 
      salta comp / 27  ;
      frente comp / 27 ; 
      salta comp / 9   ;
      frente comp / 27 ;
      salta comp / 27  ; 
      frente comp / 27 ;
      salta comp / 6   ;
      t
      dir 180
      salta comp
      esq 135
      ;frente (comp * sqrt 2) 
      salta (comp * sqrt 2) / 2   ;
      frente (comp * sqrt 2) / 27 ;
      salta (comp * sqrt 2) / 27  ;
      frente (comp * sqrt 2) / 27 ;
      salta (comp * sqrt 2) / 9   ;
      frente (comp * sqrt 2) / 27 ;
      salta (comp * sqrt 2) / 27  ;
      frente (comp * sqrt 2) / 27 ;
      salta (comp * sqrt 2) / 6   ;
      t
      dir 180
      salta (comp * sqrt 2)
      esq 135
    ]
  muda_cor
  m         
  set comp comp / 3         
end

;Para o desenho do Quadrado de Sierpinski 2 o procedimento usado é diferente do procedimento usado anteriormente
;aqui não se faz uso do agente turtles
to QsierpinskiSetup2 ;inicializa as variáveis necessárias para seguidamente se efectuar o desenho do quadrado de Sierpinski 
  ca
  set iteracao 0
  ask patches with[ 121 >  pxcor and 121 > pycor and pxcor > -121 and pycor > -121 ]
    [ set pcolor cor-inic  ] ;pinta o quadrado inicial, tem um lado de 243=3^5 para que se possa chegar à resolução do patch (=pixel)        
  set comp 81 ;lado de cada quadrado em que se dividiu o quadrado maior  
  set N 81    ;indica o número de patches do lado do quadrado da maior divisão pretendida
              ;no início é 81 pois não se quer fazer divisão nenhuma 
  set Asierpinski? false
  set koch? false
  set Qsierpinski? false
  set Qsierpinski2? true
end

to QuadradoSierpinski2   
  DesenhaNivelN (- 121) (- 121) comp  ;passo à fc o canto inferior esquerdo do quadrado, o seu lado e o lado do quadrado até onde se pretende dividir
  set N N / 3              ;passa-se para uma divisão maior, ou seja, um lado do quadrado menor 
end

to DesenhaNivelN [ pxcorini pycorini compini ] ;função recursiva que se chama a ela própria até comprini (comprimento inicial) ser igual a N 
  ifelse N = compini
    [
      qDesenha pxcorini pycorini compini;se os dois comprimentos forem iguais então a partição pretendida foi atingida e pinta o quadrado central 
    ]
    [             ;se o comprimento não foi atingido chama-se novamente nos quadrados mais pequenos (excepto no central)
      DesenhaNivelN pxcorini pycorini (compini / 3)  
      DesenhaNivelN (pxcorini + compini) pycorini (compini / 3)  
      DesenhaNivelN (pxcorini + 2 * compini) pycorini (compini / 3)  
      DesenhaNivelN pxcorini (pycorini + compini) (compini / 3) 
      DesenhaNivelN (pxcorini + 2 * compini) (pycorini + compini) (compini / 3)  
      DesenhaNivelN pxcorini (pycorini + 2 * compini) (compini / 3) 
      DesenhaNivelN (pxcorini + compini) (pycorini + 2 * compini) (compini / 3)  
      DesenhaNivelN (pxcorini + 2 * compini) (pycorini + 2 * compini) (compini / 3)  
    ]
end

;dado um quadrado cujas coordenadas do canto inf. esq. são (qpxcor,qpycor) e o cujo lado é qcomp, esta fc divide-o 
;em nove quadrados iguais e pinta de negro o quadrado do meio
to qDesenha [ qpxcor qpycor qcomp ]
  ask patches with [ pxcor >= (qpxcor + qcomp) and (2 * qcomp + qpxcor) > pxcor and pycor >= (qpycor + qcomp) and (2 * qcomp + qpycor) > pycor ]
    [ set pcolor black ]
end

; Versão ICES Copyright 2004, Centro de Física Teórica e Computacional

; *** NetLogo Model Copyright Notice ***
;
; This model was created as part of the project:
; PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN
; CLASSROOMS.  The project gratefully acknowledges the support of the
; National Science Foundation (REPP program) -- grant number REC #9814682.
;
; Copyright 2001 by Uri Wilensky.  Updated 2001.  All rights reserved.
;
; Permission to use, modify or redistribute this model is hereby granted,
; provided that both of the following requirements are followed:
; a) this copyright notice is included.
; b) this model will not be redistributed for profit without permission
;    from Uri Wilensky.
; Contact Uri Wilensky for appropriate licenses for redistribution for
; profit.
;
; To refer to this model in academic publications, please use:
; Wilensky, U. (2001).  NetLogo L-SystemFractals model.
; http://ccl.northwestern.edu/netlogo/models/L-SystemFractals.
; Center for Connected Learning and Computer-Based Modeling,
; Northwestern University, Evanston, IL.
;
; In other publications, please use:
; Copyright 1998 by Uri Wilensky.  All rights reserved.  See
; http://ccl.northwestern.edu/netlogo/models/L-SystemFractals
; for terms of use.
;
; *** End of NetLogo Model Copyright Notice ***
@#$#@#$#@
GRAPHICS-WINDOW
422
13
946
558
256
256
1.002
1
10
1
1
1

CC-WINDOW
8
439
412
592
Command Center

BUTTON
23
131
185
164
Desenhar uma iteração
desenhar
NIL
1
T
OBSERVER
T

SLIDER
215
171
403
204
cor-incremento
cor-incremento
0
100
10
1
1
NIL

SLIDER
215
131
403
164
cor-inic
cor-inic
0
140
15
1
1
NIL

BUTTON
23
170
185
203
Desenhar
desenhar
T
1
T
OBSERVER
T

BUTTON
23
30
207
63
Árvore de Sierpinski
AsierpinskiSetup
NIL
1
T
OBSERVER
T

BUTTON
23
71
207
104
Ilha de Koch
kochSetup
NIL
1
T
OBSERVER
T

MONITOR
23
226
149
275
Nº Tartarugas
count turtles
10
1

BUTTON
215
30
403
63
Quadrado de Sierpinski
QsierpinskiSetup
NIL
1
T
OBSERVER
T

BUTTON
215
71
403
104
Quadrado de Sierpinski 2
QsierpinskiSetup2
NIL
1
T
OBSERVER
T

BUTTON
422
559
561
592
Exportar Mundo
exportarmundo
NIL
1
T
OBSERVER
T

MONITOR
172
226
259
275
NIL
int iteracao
0
1

@#$#@#$#@
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 -7566196 true true 150 5 40 250 150 205 260 250

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

box
true
0
Polygon -7566196 true true 45 255 255 255 255 45 45 45

circle
true
0
Circle -7566196 true true 35 35 230

line
true
0
Line -7566196 true 150 0 150 295

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

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

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

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

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

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

turtle
true
0
Polygon -7566196 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 2.0.0
@#$#@#$#@
ballSetup
repeat 14 [ iterate ]
@#$#@#$#@
@#$#@#$#@