Primeira vez aqui? Seja bem vindo e cheque o FAQ!
x

Como interpreto e gero representações tree OL- system?

+1 voto
68 visitas
perguntada Abr 5, 2017 em Ciência da Computação por IgorNascimento (51 pontos)  
Compartilhe

1 Resposta

+1 voto
respondida Abr 5, 2017 por IgorNascimento (51 pontos)  
editado Abr 6, 2017 por IgorNascimento

Esse tipo de representação é composto por:
• Conjunto de vértices \(V\) que possuem denominações e sentido
• Segmento inicial \(w\) com mesmas denominações \(V\)
• Regra de produção \(P\)

Para regra de produção \(P\) utilizam-se as seguintes notações:
• Sequência de tarefas representado por letras (ex.: \(A\),\(B\),...,\(Z\))
• compostas por tarefas de deslocamento para frente (\(F\))
• compostas por tarefas de rotações em sentido horário ou anti-horário.
• “[“ início branch
• “]” fim branch

É importante notar que pode haver mais de uma regra, isto é, combinações de regras \(P_1\),\(P_2\),...,\(P_k\).
Geração de imagens a partir do tree OL-system será feita utilizando os seguintes movimentos:
1. Forward: passos para frente, representado por (\(F\))
2. Backward: passos para trás, representado por (\(B\))
3. Left: rotação para direita da direção atual, representado por “-“
4. Right: rotação para a esquerda da direção atual, representado por “+”

O figura a baixo ilustra tais movimentos básicos.

A imagem será apresentada aqui.

A figura abaixo apresenta um exemplo de representação OL-system:

A imagem será apresentada aqui.

Analisando mais detalhadamente, tem-se a seguinte leitura da representação:

A imagem será apresentada aqui.

Nesse tipo de representação é possível parametrizar a ângulo das rotações (δ) e o número de níveis ou réplicas do processo (n).

A Figura 1.24 (e) do livro "The algorithmic Beaty of Plants" apresenta um exemplo de tal representação. A imagem e o argumento para gerar a imagem é:

A imagem será apresentada aqui.

Isso que dizer que:

  1. O processo será replicado em 7 camadas recursivas.
  2. O ângulo de rotação a direita ou a esquerda é de δ=27.5°
  3. O processo inicial é \(w=\) X
  4. Há duas regras de produção X e F:
    4.a X -> F[+X][-X]FX
    4.b F -> FF

O item 4.a é possível notar que, a cada recursão, há três branchs:

  1. Principal: F...FX
  2. Uma secundária recursiva à esquerda: ...[+X]...
  3. Uma terceira recursiva à direita: ...[-X]...

O item 4.b informa que cada passo a frente deve ser realizados duas vezes consecutivas.

O comando para gerar tal imagem em Python utiliza duas funções, relacionadas às tarefas de todas as regras de produção X e F. A programação foi desenvolvida de maneira que ponteiro de desenho volte à posição inicial.

O primeiro chunck apresenta as bibliotecas utilizadas.

from turtle import *

O segundo chunck apresenta a função associada à primeira regra de produção X, que por sua vez, é o processo inicial da representação \(w\). Os parâmetros para essa função são:

  1. n: número de recursividades necessárias
  2. alpha: ângulo de rotação
  3. x: tamanho da aresta entre os nós

    def w(n,alpha,x):
    if n == 0:
        return
    else:
        F(n-1,alpha,x)    # 1º F
        left(alpha)          # sinal "+" para a 1ª recursão
        w(n-1,alpha,x/2) # 1ª recursão
        right(alpha) # voltando para sentido principal da branch
        right(alpha) # sinal "-" para a 2ª recursão
        w(n-1,alpha,x/2) # 2ª recursão
        left(alpha) # voltando para sentido principal da branch
        F(n-1,alpha,x)  # 2º F
        w(n-1,alpha,x/2) # 3ª recursão
        backward(x) # 1º retorno do 1º F
        backward(x) # 2º retorno do 1º F
        backward(x) # 1º retorno do 2º F
        backward(x) # 2º retorno do 2º F
    

O terceiro chunck está associado à segunda regra de produção \(F\). São utilizados os mesmos parâmetros da função \(w\).

def F(n,alpha,x):
    if(n==0):
        forward(x)
        forward(x)
    else:
        F(n-1,alpha,x/2)
        F(n-1,alpha,x/2)

Para chamar a função, faz-se:

if __name__ == '__main__':
    begin_fill()
    Screen()
    penup()             # desabilitar a caneta
    goto(0,-250)    # posiciona a caneta em um ponto específico da grid
    pendown()       # habilita a caneta
    left(90)              # direciona a caneta para o início do processo
    width(1.5)        # define o tamanho da linha para o desenho
    w(7,27.5,50)   # chama a função w com parâmetros estabelecidos
    done()

O resultado da programação é:
A imagem será apresentada aqui.

Referências:
The Algorithmic Beaty of Plants.

...