"""
Aranha (2 partes) ou Insecto (3 partes) de tamanho variável
6 ou 8 patas variáveis (8 se for aranha)
2 olhos variáveis ou mais se for aranha
1 a 3 pares variáveis de mandibulas
0 a 2 pares variáveis de antenas se for insecto
0 a 2 pares variáveis de asas se for insecto
"""
 
# devolve valor relativo a proporção (importado do Processing)
def map(value,istart,istop,ostart,ostop):
    return ostart+(ostop-ostart)*((value-istart)/(istop-istart))
# devolve a distancia entre dois pontos
def distance(x0,y0,x1,y1):
    from math import sqrt,pow
    return sqrt(pow(x1-x0,2)+pow(y1-y0,2))
# devolve coordenadas de um ponto a uma distancia e angulo de outro
def rel_coordinates(x0,y0,distance,angle):
    from math import radians,sin,cos
    x1=x0+cos(radians(angle))*distance
    y1=y0+sin(radians(angle))*distance
    return x1,y1
# devolve o angulo entre dois pontos
def angle(x0,y0,x1,y1):
    from math import degrees,atan2
    a=degrees( atan2(y1-y0,x1-x0) )
    return a
# oval a partir do centro
def oval_from_center(x,y,w,h,drawing=True):
    x=x-w/2
    y=y-h/2
    if drawing==True:
        oval(x,y,w,h)
    else:
        return oval(x,y,w,h,draw=False)
# devolve lista de partes, proporção (tamanho) de cada parte
def parts(parts_number,start_x,start_y,length,angle):
    parts=list() # (size_x,size_y,rad_size,brightness)
    head_size=random(.15,.45)/(parts_number-1)
    head_width=random(.9,1.1)*head_size
    head_rad=random(2.1,3.) # falsos radius (menores)
    parts.append((head_size,head_width,head_rad,random(-.25,.25)))
    tor_size=0
    if parts_number==3:
        tor_size=random(.1,.45)
        tor_width=random(.85,1.5)*head_size
        tor_rad=random(2.1,3.)
        parts.append((tor_size,tor_width,tor_rad,random(-.25,.25)))
    abd_size=1-head_size-tor_size
    abd_width=random(1.25*head_size,abd_size*.75)
    abd_rad=random(2.1,3.)
    parts.append((abd_size,abd_width,abd_rad,random(-.25,.25)))
    parts.reverse() # tails first
    return parts
 
size(400,400)
colormode(HSB)
background(1)
 
# Cores ternárias
main_color=random(0.,1.)
alt_color=main_color+.33 if main_color+.33<1 else main_color-.66
alt_color_2=main_color-.33 if main_color-.33>0 else main_color+.66
 
# Inicio e fim do insecto, opções
body_start=(random(0,WIDTH),random(0,HEIGHT))
body_end=None
while body_end==None or distance(body_start[0],body_start[1],body_end[0],body_end[1])<(WIDTH/3):
    body_end=(random(WIDTH/4,WIDTH*3/4),random(HEIGHT/4,HEIGHT*3/4))
parts_number=random(2,3)
 
# Dados principais
body_angle=angle(body_start[0],body_start[1],body_end[0],body_end[1])
body_length=distance(body_start[0],body_start[1],body_end[0],body_end[1])
parts=parts(parts_number,body_start[0],body_start[1],body_length,body_angle)
 
#PERNAS
stroke(main_color,0.5,0.1)
translate(body_start[0],body_start[1])
leg_center_part=1
leg_pairs_number=4 if len(parts)==2 else random(3,4)
leg_center=rel_coordinates(0,0,((2*((parts[0][0]*body_length)/parts[0][2]))+(parts[leg_center_part][0]*body_length)/parts[leg_center_part][2]),body_angle)
start_angle=body_angle+random(-100.,-80.)
leg_angle=random(30.,50.)
leg_angle_wide=leg_angle+random(30.,90.)
leg_angle_increment=leg_angle/(leg_pairs_number-1)
leg_angle_increment_wide=(leg_angle_wide/(leg_pairs_number-1))
leg_size=random(.8,1.25)*parts[leg_center_part-1][0]*body_length
leg_ratio=random(2.5,3.5)
leg_width=random(1,2)*3
for i in range(2):
    for j in range(leg_pairs_number):
        angle=(start_angle-leg_angle/2)+j*(leg_angle_increment*random(.9,1.1))
        angle_wide=(start_angle-leg_angle_wide/2)+j*(leg_angle_increment_wide*random(.9,1.1))
        angle_middle=angle+(angle_wide-angle)/random(1.9,2.1)
        leg_end_0=rel_coordinates(leg_center[0],leg_center[1],leg_size/3,angle)
        leg_end_1=rel_coordinates(leg_center[0],leg_center[1],leg_size*2/3,angle_middle)
        leg_end_2=rel_coordinates(leg_center[0],leg_center[1],leg_size,angle_wide)
        strokewidth(leg_width)
        line(leg_center[0],leg_center[1],leg_end_0[0],leg_end_0[1])
        strokewidth(leg_width*2/3)
        line(leg_end_0[0],leg_end_0[1],leg_end_1[0],leg_end_1[1])
        strokewidth(leg_width/3)
        line(leg_end_1[0],leg_end_1[1],leg_end_2[0],leg_end_2[1])
    start_angle+=180
 
#CORPO
nostroke()
reset()
transform(mode=CENTER)
translate(body_start[0],body_start[1])
for part in parts:
    part_rad=rel_coordinates(0,0,(part[0]*body_length)/part[2],body_angle)
    translate(part_rad[0],part_rad[1])
    push()
    rotate(-body_angle)
    fill(main_color,.3,.5+part[3])
    oval_from_center(0,0,part[0]*body_length,part[1]*body_length)
    pop()
    translate(part_rad[0],part_rad[1])
parts.reverse()
 
#HEAD
head_center=rel_coordinates(0,0,(parts[0][0]*body_length)/parts[0][2],180+body_angle)
translate(head_center[0],head_center[1])
 
#MANDIBULAS
stroke(main_color,.1,.1)
jaw_pairs=random(1,3)
for i in range(jaw_pairs):
    m=1
    jaws_angle=random(5.,40.)
    jaws_angle_inner=random(.2,.7)*jaws_angle
    jaws_size=random(.55,.7)*parts[0][1]*body_length
    jaws_closure=random(.75,1.25)
    for j in range(2):
        jaw_0=rel_coordinates(0,0,parts[0][0]*body_length/2,body_angle+m*jaws_angle/2)
        jaw_1=rel_coordinates(0,0,jaws_size*jaws_closure,body_angle+m*jaws_angle/2)
        jaw_2=rel_coordinates(0,0,jaws_size,body_angle+m*jaws_angle_inner/2)
        strokewidth(2)
        line(jaw_0[0],jaw_0[1],jaw_1[0],jaw_1[1])
        strokewidth(1)
        line(jaw_1[0],jaw_1[1],jaw_2[0],jaw_2[1])
        m*=-1 
 
#OLHOS
nostroke()
fill(alt_color,.5,.5)
eye_pairs=random(2,8) if len(parts)==2 else 1
eye_size=(random(.1,.45)*parts[0][1]*body_length)/eye_pairs
for i in range(eye_pairs):
    eye_angle=random(20.,160.)
    eye_d=random(.25,.5)*parts[0][1]*body_length
    eye_l=rel_coordinates(0,0,eye_d,body_angle+eye_angle/2)
    eye_r=rel_coordinates(0,0,eye_d,body_angle-eye_angle/2)
    oval_from_center(eye_l[0],eye_l[1],eye_size,eye_size)
    oval_from_center(eye_r[0],eye_r[1],eye_size,eye_size)
 
#ANTENAS
if len(parts)==3:
    stroke(main_color,.1,.1)
    nofill()
    antenna=random(0,1)
    if antenna==1:
        antenna_pairs=random(0,2)
        for i in range(antenna_pairs):
            antenna_d=random(.1,.2)*parts[0][1]*body_length
            antenna_size=random(.15,.4)*body_length
            antenna_angle=random(60.,100.)
            antenna_angle_2=antenna_angle+random(-20.,20.)
            antenna_ratio=random(.3,.8)
            m=1
            for j in range(2):
                antenna_0=rel_coordinates(0,0,antenna_d,body_angle+m*120)
                antenna_1=rel_coordinates(0,0,antenna_size*antenna_ratio,body_angle+m*antenna_angle_2/2)
                antenna_2=rel_coordinates(0,0,antenna_size,body_angle+m*antenna_angle/2)
                autoclosepath(False)
                path = findpath([(antenna_0[0],antenna_0[1]),(antenna_1[0],antenna_1[1]),(antenna_2[0],antenna_2[1])])
                drawpath(path)
                m*=-1
 
#ASAS
nostroke()
fill(alt_color_2,.2,1,.5)
if len(parts)==3 and random(0,1)==1:
    reset()
    translate(body_start[0]+leg_center[0],body_start[1]+leg_center[1])
    wing_pairs=random(1,2)
    for i in range(wing_pairs):
        wing_d=random(.1,.2)*parts[1][1]*body_length
        wing_size=random(.75,1.1)*body_length
        wing_width=random(.3,.6)*wing_size
        wing_angle=random(-20,70)
        m=1
        for j in range(2):
            wing_0=rel_coordinates(0,0,wing_size/2+wing_d,body_angle+m*90+m*wing_angle)
            push()
            translate(wing_0[0],wing_0[1])
            rotate(-body_angle+90-m*wing_angle)
            oval_from_center(0,0,wing_size,wing_width)
            pop()
            m*=-1

# REQUISITOS:
# logo-espiral.png
# Museo 300; Museo 700 e Museo Slab 500
# devolve valor relativo a proporção (importado do Processing)
def map(value,istart,istop,ostart,ostop):
return ostart+(ostop-ostart)*((value-istart)/(istop-istart))
 
# devolve a distancia entre dois pontos
def distance(x0,y0,x1,y1):
from math import sqrt,pow
return sqrt(pow(x1-x0,2)+pow(y1-y0,2))
 
# devolve coordenadas de um ponto a uma distancia e ângulo de outro
def rel_coordinates(x0,y0,distance,angle):
from math import radians,sin,cos
x1=x0+cos(radians(angle))*distance
y1=y0+sin(radians(angle))*distance
return x1,y1
 
# devolve o ângulo entre dois pontos
def angle(x0,y0,x1,y1):
from math import degrees,atan2
a=degrees( atan2(y1-y0,x1-x0) )
return a
 
# devolve o ângulo “absoluto” entre dois pontos
def abs_angle(x0,y0,x1,y1):
a=angle(x0,y0,x1,y1)
return a if a >= 0 else 360+a
 
# devolve conjunto de pontos intermédios para os “arcos”
def get_control_points(center_point,angle0,angle_between,start_dist=0,increment=0,multiplier=0):
# angle0 => angulo inicio do “arco”
# angle_between => duração do arco
from math import ceil
points=list()
x0,y0=center_point[0],center_point[1]
# numero de pontos de controle; um por grau; não seria obrigatório calcular tantos mas foi o melhor compromisso encontrado
n_ps=ceil(angle_between/1)
angle=angle_between/n_ps
# r proporção da curva que será suavizada (pontas): 2/15 avos do “arco” serão “suavizados”
r=n_ps/15
for i in range(1,n_ps):
# suavizar inicio do arco
if i <= r:
distance=start_dist+i*multiplier*increment/r
# suavizar fim do arco
elif i >= n_ps-r:
distance=start_dist+(n_ps-i)*multiplier*increment/r
# manter a mesma distancia ao longo do arco
else:
distance=start_dist+multiplier*increment
px,py=rel_coordinates(x0,y0,distance,angle0+i*angle)
points.append((px,py))
return points
 
size(420*1.1,594*1.1)
sc=1.1
background(1)
colormode(HSB)
# Cores (triade)
h=random(0,1.)
# h2 não está a ser utilizada
h2=h+.333 if h+.333 <= 1 else h-.666
h3=h-.333 if h-.333 <= 1 else h+.666
# regular saturação da cor de fundo
fill(h,.7,1)
nostroke()
# forçar fundo
rect(0,0,WIDTH,HEIGHT)
stroke(h3,.5,1)
nofill()
# rotação do labirinto
rotation=random(0,360)
# centro do labirinto
center_point=(random(WIDTH/10,9*WIDTH/10),random(HEIGHT/10,9*HEIGHT/10))
# largura do traço do labirinto
stroke_width=random(3.,15.)*sc
# numero de ramos
branches_number=random(2,5)
# tamanho dos ramos
branches_size=random(30.,50.)*sc
# referencia de espaço entre “camadas”
spacing=branches_size/random(3,5)+stroke_width
strokewidth(stroke_width)
 
# desenhar ramos
branches_angle=360/branches_number
# conjunto com extremidade de cada ramo
branch_ends=list()
for i in range(branches_number):
x1,y1=rel_coordinates(center_point[0],center_point[1],branches_size,(i+1)*branches_angle+rotation)
line(center_point[0],center_point[1],x1,y1)
branch_ends.append((x1,y1))
# calcular arcos e pontos
arcs=list()
dots=list()
# offset dos arcos iniciais em relação ao tamanho dos ramos
arcs_offset=spacing/4+stroke_width
# percentagem do angulo entre ramos ocupado por cada arco
arcs_ratio=.5
# offset dos pontos iniciais em relação ao tamanho dos ramos
dots_offset=spacing+stroke_width
 
# calcular arcos e pontos
for i in range(len(branch_ends)):
j=i+1 if i+1<len(branch_ends) else 0
arc_angle=branches_angle*arcs_ratio
#ponto inicial de arco
x1,y1=rel_coordinates(center_point[0],center_point[1],branches_size+arcs_offset,(i)*branches_angle+((branches_angle-arc_angle)/2.)+rotation)
# ponto intermédio da curva do arco
x2,y2=rel_coordinates(center_point[0],center_point[1],branches_size,(i)*branches_angle+branches_angle/2.+rotation)
# ponto final do arco
x3,y3=rel_coordinates(center_point[0],center_point[1],branches_size+arcs_offset,(i+1)*branches_angle-((branches_angle-arc_angle)/2.)+rotation)
arcs.insert(i,[(x1,y1),(x2,y2),(x3,y3)])
# ponto
d1x,d1y=rel_coordinates(center_point[0],center_point[1],branches_size+dots_offset,(i)*branches_angle+branches_angle/2.+rotation)
dots.insert(i,(d1x,d1y))
 
# desenhar arcos
for arc in arcs:
path=findpath(arc)
# suavizar pontos de união com arcos
oval(arc[0][0]-stroke_width/10.,arc[0][1]-stroke_width/10.,stroke_width/10.,stroke_width/10.)
oval(arc[2][0]-stroke_width/10.,arc[2][1]-stroke_width/10.,stroke_width/10.,stroke_width/10.)
drawpath(path)
 
# desenhar pontos
for dot in dots:
oval(dot[0]-stroke_width/10.,dot[1]-stroke_width/10.,stroke_width/10.,stroke_width/10.)
 
# criar lista ordenada de pontos a unir para desenhar espiral
ends=list()
for i in range(branches_number):
# dot
ends.append((dots[i][0],dots[i][1]))
# same arc end (end)
ends.append((arcs[i][2][0],arcs[i][2][1]))
# next branch end
ends.append((branch_ends[i][0],branch_ends[i][1]))
# next arc end (start)
j=i+1 if i+1<len(branch_ends) else 0
ends.append((arcs[j][0][0],arcs[j][0][1]))
 
# unir pontos
reverse_i=0
start_i=random(0,len(ends)-1)
for i in range(len(ends)/2):
j=i+1 if i+1<len(ends) else 0
# angulo inicio
i_angle=abs_angle(center_point[0],center_point[1],ends[reverse_i][0],ends[reverse_i][1])
# angulo fim
j_angle=abs_angle(center_point[0],center_point[1],ends[j][0],ends[j][1])
# diferença angulos, angulo a cobrir pelo arco
d_angle=j_angle-i_angle if j_angle-i_angle>0 else 360+(j_angle-i_angle)
curve_points=list()
curve_points.append((ends[reverse_i][0],ends[reverse_i][1]))
# buscar pontos de controle
control_points=get_control_points(center_point,i_angle,d_angle,distance(center_point[0],center_point[1],ends[reverse_i][0],ends[reverse_i][1]),4*spacing,i)
curve_points.extend(control_points)
curve_points.append((ends[j][0],ends[j][1]))
path=findpath(curve_points)
drawpath(path)
# ver pontos de controle:
#    oval(dot[0],dot[1],1,1)
reverse_i=(len(ends)-1)-i
 
# Caixa texto
from math import tan,radians,degrees,sin
nostroke()
fill(0,0,0,.2)
# incliniação topo
angle_top=random(-10.,5.)
# incremento para inclinação fundo
add_angle=10.
angle_bottom=angle_top+add_angle
angle_top,angle_bottom=radians(angle_top),radians(angle_bottom)
# inicio horizontal
box_x=WIDTH/7
# calcular altura da caixa conforme angulo gerado
box_top_left=map(degrees(angle_top),-10.,5.,HEIGHT/7,3*HEIGHT/8)
# dados para caixa
box_top_right=box_top_left+(tan(angle_top)*(WIDTH-box_x))
box_bottom_left=box_top_left+200
box_bottom_right=box_bottom_left+(tan(angle_bottom)*(WIDTH-box_x))
beginpath(box_x,box_top_left)
lineto(box_x,box_bottom_left)
lineto(WIDTH,box_bottom_right)
lineto(WIDTH,box_top_right)
# não será impressa
endpath(draw=False)
 
# gerar frase
verbos=[“A que sabe \n”,
“A que cheira \n”,
“Qual o toque \nd”,
“A que soa \n”,
“Como é “]
# lista de suubstantivos, para cada um incluimos lista de indices de verbos excluidos
substantivos=[(“o amarelo”,[4]),
(“o verde”,[4]),
(“o branco”,[4]),
(“o cinzento”,[4]),
(“o azul”,[4]),
(“o vermelho”,[4]),
(“a lua”,[4]),
(“a confiança”,[-1]),
(“o amor”,[-1]),
(“o ódio”,[-1]),
(“a dança”,[-1]),
(“o sagrado”,[-1]),
(“o inesperado”,[-1]),
(“a cura”,[-1]),
(“a espera”,[-1]),
(“a cultura”,[-1]),
(“o crescimento”,[-1]),
(“a distância”,[-1]),
(“a procura”,[-1]),
(“o sonho”,[-1]),
(“uma flor”,[0,1,2,4]),
(“o chá”,[0]),
(“o vento”,[3]),
(“o sol”,[-1]),
(“a música”,[3]),
(“a amizade”,[-1]),
(“a descoberta”,[-1]),
(“a comunicação”,[3]),
(“a laranja”,[0,1,2,4])]
i=random(0,len(verbos)-1)
chose=False
while chose==False:
s=choice(substantivos)
# verificar se i está excluido
if i in s[1]:
chose=False
else:
chose=True
frase=str(verbos[i])+str(s[0])+”?”
frases=[frase,
“10 Dezembro, Fio de Ariadne”,
“Inauguração da Espiral de Imaginação Associação Cultural”,
“www.Espiral-de-Imaginação.pt”,
“Rua de Cedofeita 451,Porto”]
# Fonte, Tamanho, Leading (relativo a tamanho)
fontes=[(“Museo 700”,50,.75),
(“Museo Slab 500”,25,1),
(“Museo Slab 500”,20,1),
(“Museo 700”,15,1),
(“Museo 300”,15,1)]
fill(1)
# angulo de rotação actual, começamos com angulo gerado para caixa
cur_angle=-degrees(angle_top)
rotate(cur_angle)
# coordenadas iniciais (mesma da caixa)
cur_x=WIDTH/7
cur_y=box_top_left
# calcular incremento na rotação conforme numero de frases
angle_increment=-add_angle/len(frases)
for i in range(len(frases)):
# valor da variação horizontal provocada pela rotação
dx=(textwidth(frases[i])/2)*(1-cos(radians(cur_angle)))
# valor da variação vertical provocada pela rotação
m=1 if cur_angle>=0 else -1
dy=m*(textwidth(frases[i])/2)*sin(radians(cur_angle))
font(fontes[i][0],fontes[i][1])
lineheight(fontes[i][2])
text(frases[i],cur_x+dx,cur_y,6*WIDTH/7)
# incrementar altura para proxima frase
cur_y+=textheight(frases[i],5*WIDTH/7)+dy/2
# incrementar rotação para proxima frase
rotate(angle_increment)
cur_angle+=angle_increment
 
# imprimir logo
cur_y+=HEIGHT/30
image(“logo-espiral.png”,cur_x,cur_y,WIDTH/6)