Zen ou a Arte de Programar

(brincadeiras de um sábado de manhã)


Suponham que lhe pedem um programa capaz de desenhar o símbolo do Yin-Yang:

Por onde começar?? Olhando para a figura verificamos que é composta à base de circunferências e semi-circunferências a duas cores (preto e branco). Usando um princípio já nosso conhecido, tentemos simplificar a questão, esquecendo os círculos interiores e as cores:

view sourceprint?

1.def zen1(raio):

2.    turtle.setheading(90)

3.    turtle.circle(raio)

4.    turtle.circle(raio/2,-180)

5.    turtle.setheading(90)

6.    turtle.circle(raio/2,180)

Executando o código é criado o seguinte:

Ao fazermos assim ficamos com o problema de colocar as cores… Com um pouco de reflexão chegamos a uma solução, baseada na ideia de separar a circunferência exterior em duas semi-circunferências. O cuidado a ter é com as orientações a cada momento da tartaruga. Aqui basta não esquecer o principio de que a tartaruga quando se movimenta vê sempre o centro à sua esquerda!

view sourceprint?

01.def zen11(raio):

02.    turtle.setheading(90)

03.    turtle.circle(raio,180)

04.    turtle.fillcolor('black')

05.    turtle.begin_fill()

06.    turtle.circle(raio/2,-180)

07.    turtle.setheading(270)

08.    turtle.circle(raio/2,180)

09.    turtle.circle(raio,-180)

10.    turtle.end_fill()

ao executar o programa obtemos:

Agora é “só” colocar os círculos pequenos. Uma vez mais basta saber definir os centros:

view sourceprint?

01.def zen12(raio):

02.    turtle.setheading(90)

03.    turtle.circle(raio,180)

04.    turtle.fillcolor('black')

05.    turtle.begin_fill()

06.    turtle.circle(raio/2,-180)

07.    turtle.setheading(270)

08.    turtle.circle(raio/2,180)

09.    turtle.circle(raio,-180)

10.    turtle.end_fill()

11.    # círculos pequenos

12.    # esquerdo

13.    turtle.setx(turtle.xcor() + raio/2 -raio/10)

14.    turtle.fillcolor('white')

15.    turtle.begin_fill()

16.    turtle.circle(raio/10)

17.    turtle.end_fill()

18.    # direito

19.    turtle.penup()

20.    turtle.setx(turtle.xcor()+ raio)

21.    turtle.pendown()

22.    turtle.fillcolor('black')

23.    turtle.begin_fill()

24.    turtle.circle(raio/10) 

25.    turtle.end_fill()

26.    turtle.hideturtle()   

Et voilá!

Mas será que é a única forma de resolver o problema? Será que ficamos satisfeitos??? Olhando para a solução acima o que podemos dizer? Bem, que há muita coisa “fixa”: a posição, a orientação, as cores. Embora estas duas últimas façam parte da definição clássica da imagem, podemos procurar libertar-mo-nos e permitir uma versão mais geral. Por outro lado, e talvez mais importante, o modo como construímos a solução usa componentes de baixo nível e não olha para a imagem como sendo composta por duas que se distinguem … pela posição, orientação e cores!!! Vamos tentar então uma segunda abordagem.

view sourceprint?

01.def zen(raio,x_cor,y_cor,orient, cor_1,cor_2):

02.    """

03.    Desenha uma componente.

04.    """

05.    # corpo principal

06.    vai_para_or(x_cor,y_cor,orient)

07.    turtle.fillcolor(cor_1)

08.    turtle.begin_fill()

09.    turtle.circle(raio,-180)

10.    #vai_para_or(x_cor,y_cor,orient)  

11.    turtle.circle(raio/2,-180)

12.    turtle.setheading(turtle.heading()+180)

13.    turtle.circle(raio/2,180)

14.    turtle.end_fill()

15.    # restaura

16.    vai_para_or(x_cor,y_cor,orient+90)

17.    # círculo pequeno 

18.    turtle.penup()

19.    turtle.forward(3*raio/2-raio/10)

20.    turtle.pendown()

21.    turtle.fillcolor(cor_2)

22.    turtle.setheading(orient)

23.    turtle.begin_fill()

24.    turtle.circle(raio/10)

25.    turtle.end_fill()

26.    turtle.hideturtle()

O código apresentado torna mais claro a importância da orientação em cada momento do desenho. O raio do círculo pequeno foi decidido que tenha um valor 10 vezes mais pequeno que o raio da semi-circunferência maior. O resultado quando escolhemos as cores vermelho e azul:

Agora podemos apresentar o nosso programa para o Yin-Yang:

view sourceprint?

1.def yin_yang(raio,posx,posy):

2.    zen(raio,posx,posy,90,'black','white')

3.    zen(raio,posx - 2*raio,posy,270, ‘white','black')

Com esta solução podemos então … brincar:

view sourceprint?

1.def zen_rose(raio,posx,posy,orientacao,cor_1, cor_2, num):

2.    for i  in range(num):

3.        zen(raio,posx,posy,orientacao,cor_1,cor_2)

4.        orientacao = orientacao + 360/num

Executando vem:

Mas podemos variar um pouco:

view sourceprint?

1.def zen_rose_2(raio,posx,posy,orientacao,cor_1, cor_2, num):

2.    for i  in range(num):

3.        if i % 2 == 0:

4.            zen(raio,posx,posy,orientacao,cor_1,cor_2)

5.        else:

6.            zen(raio,posx,posy,orientacao,cor_2,cor_1)

7.        orientacao = orientacao + 360/num

Ou criar objectos mais coloridos:

view sourceprint?

1.def zen_rose_tutti(raio,posx,posy,orientacao, num):

2.    turtle.colormode(255)

3.    for i  in range(num):

4.        cor_1 = (random.randint(0,255),random.randint(0,255),random.randint(0,255))

5.        cor_2 = (random.randint(0,255),random.randint(0,255),random.randint(0,255))

6.        zen(raio,posx,posy,orientacao,cor_1,cor_2)

7.        orientacao = orientacao + 360/num

E agora:

E como alguém disse: o céu é o limite! Invente!!!

view sourceprint?

01.def zen_voa(raio,posx,posy,orientacao, num):

02.    turtle.speed(10)

03.    turtle.colormode(255)

04.    for i  in range(1,num+1):

05.        cor_1 = (random.randint(0,255),random.randint(0,255),random.randint(0,255))

06.        cor_2 = (random.randint(0,255),random.randint(0,255),random.randint(0,255))       

07.        zen(raio,posx,posy,orientacao,cor_1,cor_2)

08.        #orientacao = orientacao + 360/num

09.        posx = posx + i * raio/5

10.        posy = posy + i * raio/5

Formas, Cores e outras coisas....

O módulo turtle da linguagem Python tem um conjunto vasto de operações que podem ser exceptuadas sobre objectos do tipo turtle e sobre um mundo 2D. Durante as aulas vimos alguns exemplos de comandos básicos e o que com eles podíamos fazer. Por exemplo, para desenhar um quadrado:

view sourceprint?

1.def quadrado(lado):

2.    for i in range (4):

3.        turtle.forward(lado)

4.        turtle.right(90)

Usando esta definição como componente podemos brincar um pouco. Por exemplo, desenhar um certo número de vezes um quadrado, mudando apenas a orientação:

view sourceprint?

01.def tarta_ernesto(posx,posy):

02.    # tartaruga ernesto

03.    turtle.shape("turtle")

04.    turtle.color("yellow")

05.    turtle.speed(10)

06.    turtle.pensize(2)

07.    # posiciona

08.    turtle.penup()

09.    turtle.goto(posx,posy)

10.    turtle.pendown()

11.    # desenha

12.    for i in range(36):

13.        quadrado(150)

14.        turtle.right(10)

15.    turtle.hideturtle()

Como se pode ver existem comandos para:

- definir a forma da tartaruga

definir a cor

definir a velocidade da tartaruga

definir a espessura do rasto

O resultado é ilustrado na figura.

Mudando o ciclo no interior do programa podemos conseguir outro tipo de formas:

view sourceprint?

01.def tarta_costa(posx,posy):

02.    #tartaruga costa

03.    turtle.shape("turtle")

04.    turtle.color("blue")

05.    turtle.speed(10)

06.    turtle.pensize(2)

07.    # posiciona

08.    turtle.penup()

09.    turtle.goto(posx,posy)

10.    turtle.pendown()

11.    # desenha   

12.    for i in range(400):

13.        turtle.forward(i)

14.        turtle.right(91)

15.    turtle.hideturtle()

Tal como está escrito, a única “coisa” que controlamos e podemos variar é a posição inicial. Visualmente:

Podemos usar a mesma ideia de base (uma forma básicas que é replicada….) para criar diferentes formas coloridas. Experimente você.

Na aula foi pedido que escrevessem um programa que desenhasse espirais. Ficou claro, após alguma discussão, que o desenho iria depender de dois factores inter-relacionados: o tamanho do traço e o ângulo de viragem. Também é importante definir o número de “voltas” da espiral, claro, mas isso não causa problema de maior.

Daqui resulta um programa simples:

view sourceprint?

1.import turtle

2. 

3.def spiro(tam,k,ang,size):

4.    for i in range(size):

5.        turtle.forward(tam + k*i)

6.        turtle.right(ang)

7.    turtle.hideturtle()

Não é preciso pensarmos muito para perceber que os traços que vamos usar terão que ter o seu tamanho incrementado. Porquê? Bem, porque a não ser assim, em função do ângulo de viragem, em vez de uma espiral teremos repetições da mesma volta. E o ângulo? Se fôr muito pequeno vamos ter uma grande amplitude e dificuldade em girar 360 graus. Se fôr muito grande rapidamente os traços se intersectam. Mas o melhor é experimentar com valores concretos. Experimente tentar obter espirais com o aspecto dos das figuras. E muitas mais. Divirta-se!

Mais uma vez...

Vamos recomeçar mais uma edição da cadeira de IPRP. Como no passado vou procurar deixar aqui elementos que podem ajudar à melhor compreensão da matéria e consequente melhoria do vosso desempenho.

Estejam atentos!