Skip navigation

Monthly Archives: Maio 2009

continuamos revisões e dúvidas durante a primeira parte da sessão. depois entramos no laboratório, onde estamos a desenvolver projectos individuais, colectivos e alguns exercícios a alojar na net.

no pure data focámos noções elementares de programação visual, o que é o som digital, como o sintetisamos e o processamos temporalmente, espacialmente ou espectralmente. ler ficheiros do disco, gerar frequências, ruídos, impulsos, granular inputs,  resintetisar frequências, filtrar microfones, analisar níveis de som, criar processos interactivos. (sessões 11, 12)

ainda analisámos comunicação via rede na própria máquina ou entre várias máquinas, entre o pure data, max e o processing, openframeworks. para tal usamos o protocolo osc através de udp para ser mais rápido, criamos objectos que escrevem e lêem para a rede nos vários ambientes de programação, e por fim criámos programas exemplo que enviam valores de uma aplicação para outra.

introduzimos depois o arduino, e criámos um digitalizador de sensores. fizemos um controlador à base de ldr’s e pot’s numa breadboard, conectamos os sensores ao arduino, e criámos programas que lêem e usam os valores recebidos, gerando sons, sintetisando imagens, controlando estados dinâmicos também com piezos. vimos como o arduino ide é tão semelhante ao processing e o código que usamos também é parecido com java/c. (sessões 13, 14)

ainda fomos usar o arduino como actuador, controlando motores 5v e ventoinhas através dos outputs analógicos conseguimos emitir voltagens variáveis até 5v que controlam directamente ou através de outros componentes motores e actuadores sobre o mundo físico, criando o esboço de uma escultura cinética com led’s, motores e ventoinhas.

por agora já temos umas luzes sobre conceber e implementar interfaces híbridos que recorrem a várias tecnologias, como interfaces à base de computação física usando sensores, arduino, actuadores, outros materiais; interfaces à base de câmara analisando e confrontando as imagens que chegam, destacando posições distintas do fundo, obtendo parâmetros de localização, fazer actuar esses parâmetros; interfaces à base de som, analisando intensidades de frequências e construir listas de valores que fazem oscilar outros algoritmos.

por fim analisamos vários projectos construídos em c++ com o ambiente de programação openframeworks. analisamos a estrutura e funcionamento do compilador, linker, geração de código executável, e expandimos alguns exemplos de processing em c++. primeiro analisamos a programação por objectos, recorrendo a classes que têm variáveis e funções membros, e construímos vários exemplos em c++ que usam partículas, reconhecimento de imagem, som, comunicação por rede, interacções com sons e rato e electrónicas. (sessões 15, 16)

o c++ é mais robusto, um degrau acima na complexidade de escrever código comparado com o processing, mas  com as bibliotecas do openframeworks, torna-se extremamente simples, tal como no processing. a grande diferença é que cada sketch de processing extende a classe base papplet, enquanto que no openframeworks cada aplicação testapp extende a aplicação ofsimpleapp, que engloba a mecânica inicial necessária de uma aplicação c++.

continuamos com a análise de projectos individuais e criação de um laboratório na sala que tenha alguns projectores e câmaras para situações video-interactivas, microfones e colunas, e mesas para construir circuitos entre arduinos e sensores. brevemente mais novidades. boa semana. vejam as plantas, sugiram alternativas,

fizemos revisões de todos os conteúdos das várias linguagens que aprendemos, frisando conceitos chave de programação como variáveis, ciclos for, testes if(){}else{}, classes e objectos, chegar as variáveis a modificar, construir algoritmos base no processing, pd, arduino, openframeworks.

primeiro as noções iniciais de programação exploradas em máquinas de desenhar, onde a posição do rato serve como foco para o lançamento de novos objectos de classes programadas por nós. o sistema de coordenadas cartesiano e o sistema de coordenadas polar. (sessão 2)

primeiras noções de interactividade usando os microfones ligados ao computador, samplando a energia rms sonora, ou um espectro fft que nos dá intensidade por banda de frequência. aplicar os parâmetros do áudio em variáveis que controlam gráficos. noções de classes mais avançadas com os exemplos dos triângulos de som. (sessão 3)

paralelamente, primeiras máquinas lógicas simples, onde a nossa interacção controla um ou mais elementos, e há outros elementos que reagem face à nossa posição, distância, status, etc. os sketches círculos_attack.

depois fomos analisar o tipo de dados pimage e a biblioteca video do processing, que é um tipo de dados que armazena imagens. começamos com os sketches que acedem à informação de cor de cada pixel — criando travelers que oscilam com base nessa cor –, depois ler e scrubbing de video, gravar video e aceder a câmaras. terminamos com acessos mais elaborados à array dos pixels de cada pimage, modificando-os ou lendo-os directamente. (sessão 4)

o próximo tópico foram as partículas e sistemas de partículas, onde elementos simples mantêm variáveis de posição, velocidade, aceleração. a aceleração será o vector que controla a magnitude da deslocação. é também o vector que define a totalidade das forças aplicadas nas partículas. os próximos passos são actualizar a velocidade com a aceleração, actualizar a posição com base na nova velocidade, desenhar o elemento na nova posição. (sessão 5)

introdução ao 3d com noções de coordenadas espaciais, onde está a câmara, onde estão os objectos no espaço, como criar algorimos que gerem formas que se movimentem em três dimensões. (sessão 6)

alguns exemplos mais elaborados de video, como slitscan, delays, texturas em 3d; início do tracking de vídeo: detecção de presença, movimento, background removal, detecção de posição de centróides de blobs, frame differencing, detecção de outras features como caras, mãos, … (sessão 7, 8)

arraylists como recipientes dinâmicos de dados, texto no processing, como ler linhas de texto, separar palavras e espalhá-las espacialmente para desenhar. o sistema esférico (semelhante ao polar, mas em 3d), como desenhar pontos no espaço em forma de esfera e modificá-los com base no som. (sessão 9)

máquinas de estado simples mais avançadas, onde criamos várias classes, obstáculos, bolas, tiros, e todos elas comunicam entre si. cada bola, mesmo as autónomas colidem com os obstáculos, a nossa bola envia tiros que colidem com bolas e obstáculos, e implementamos uma lógica simples quando as bolas em cena terminam, re-iniciamos um novo nível. (sessão 10)

depois vimos puredata, arduino, open frameworks, que ficará como resumo no próximo post.

o curso está na fase laboratorial, estamos activamente a desenvolver projectos individuais e uns projectos colectivos, tirar dúvidas mais específicas em torno de algumas coisas, estamos de antenas apontadas para uma apresentação de projectos de fim de curso que ocorrerá no início de julho.

hoje focamos alguns exemplos de comportamentos de partículas mais avançados com o openframeworks. analisamos partículas em vectores c++, depois extendemos a class das partículas para incorporar forças de atracção e repulsão em função de elementos ou as outras partículas vizinhas, e vamos desembocar em exemplos de enxames. finalizamos com exemplos 3d e interacção imagem/som.

 

vectores c++

 

o primeiro passo é introduzir e saber manipular vector <tipo_de_dados> myVector; um vector é parecido com uma arraylist de java, como analisamos no processing, uma estrutura de dados que pode ser povoada dinamicamente a qualquer altura do código. declaram-se variáveis como tipo vector de um tipo de dados padrão ou por nós definido (entre <>).

 

para inserir elementos, criamos o elemento do tipo que queremos, e chamamos para o vector com a função myVector.push_back( elemento a adicionar ); a qualquer altura podemos saber o número de elementos no vector com myVector.size();, e eliminar elementos com a myVector.erase(), ou limpar todo o vector com myVector.clear();

 

na aplicação sp16_parts_vector inicializamos e gerimos as partículas com estes loops simples:

.. declarar

vector <Part> particulas;

 

.. durante a setup

// inicializar

int numparticulas = 250;

for(int i=0;i<numparticulas;i++){

Part particula;

particula.init(ofRandom(0,ofGetWidth()),ofRandom(0,ofGetHeight()));

particulas.push_back(particula);

}


.. durante a draw

for(int i=0; i<particulas.size();i++){

if(particulas[i].active )

particulas[i].render();

}

sp16-parts-vector

 

 

partículas

 

além da integração simples de novas posições a partir de velocidades, já vimos alguns exemplos onde aplicamos forças às partículas. o motor de movimento será quase sempre idêntico. o loop do sistema de partículas físico será algo como:

1. colocar as forças das partículas a zeros (acc = 0)

2. calcular novas forças para cada partícula ( acc = x )

3. adicionar a força calculada à velocidade ( vel += acc )

4. adicionar a velocidade calculada à posição ( pos += vel )

 

as inovações e coisas mais interessantes começam a surgir quando usamos diferentes formas de calcular forças a actuar nas partículas. primeiro vimos alguns exemplos onde há uma força de atracção global para todas as partículas em direcção ao rato, mas depois cada partícula recebe também uma força de repulsão em relação à posição das vizinhas, o que dá um novo tipo de organicidade ao sistema.

sp16-parts-frcs

 

outro exemplo é ter um campo de forças a actuar nas partículas, consoante a posição da partícula, vai receber um vector de direcção do campo de forças, que forçará padrões de movimento consoante as orientações dos campos de partículas.

 

sp16-vf1

 

enxames

 

os enxames vão ser um caso especial desenvolvido dos anteriores, onde cada partícula vai calcular três ou mais tipos de forças consoante a posição das partículas vizinhas. além da pos, vel, acc, vamos ter floats que pesam cada uma destas forças nas partículas. as forças nos enxames costumam ser: força de separação (pelo menos estar a distância x das outras partículas), força de coesão (força na direcção do centro de massa do enxame de distância y), força de alinhamento (força na direcção actual das restantes partículas a uma distância z).

 

o passo 2 que esboçamos anteriormente vai então desdobrar-se em pequenos sub-passos:

2.  calcular novas forças para cada partícula ( acc = x )

2.1 calcular vector de separação, coesão e alinhamento

2.2 pesar os vectores com os coeficientes das forças e somá-los para obter a acc

 

uma vez realizados estes passos temos as novas forças das partículas. os diferentes comportamentos autónomos que se podemo construir vão ter aqui o ponto-chave, que forças calcular para obter determinado tipo de comportamento em relação aos restantes elementos do enxame.

 

sp16-flocking

 

finalizamos com um exemplo que envolve som, bolas que interagem e colidem entre elas, quando tocam no chão despoletam a reprodução de um fragmento sonoro na posição temporal dependendo do x de cada bola, e de vol e duração dependendo das velocidades de impacto no chão.

 

sp16-2001

sp16-2001a

 

a partir de alguns exemplos mais avançados da sessão 16, fomos ver o trabalho pioneiro nestas áreas realizados pelo karl sims e pelo craig reynolds.

vejam alguns trabalhos pioneiros de partículas e algoritmos genéticos
karl sims (particle dreams , evolved virtual creatures, …) 

exemplos pioneiros de comportamentos autónomos
craig reynolds / steering behaviours / boids / enxames  

algumas implementações destes tópicos em processing no nature of code do daniel shiffman mostram algoritmos de enxames e algoritmos genéticos, e diferentes usos onde podemos aplicar os dados. e vejam também o curso making things move do zach lieberman com o openframeworks, onde estão alguns destes exemplos de partículas.