design a partir de formas da natureza: … · vector speed; | pvector velocity = new pvector(1,...

Departamento de Artes e Design

DESIGN A PARTIR DE FORMAS DA NATUREZA: INVESTIGAÇÕES E PROCESSOS NOS MEIOS DIGITAIS

Aluno: Anderson de Araújo Braz Orientadores: Luiza Novaes e João de Sá Bonelli

Introdução Neste projeto de iniciação científica pesquisamos o desenvolvimento de desenhos e interações digitais desenvolvidos através de programação de computadores, e suas possibilidades para o campo do Design. O estudo utiliza como referência o livro The Nature of Code (SHIFFMAN, 2012). No livro, Shiffman propõe o desenvolvimento de algoritmos baseados em conceitos de Geometria e de Física aplicados à geração de imagens artísticas. A partir da investigação das técnicas propostas, foram geradas imagens e animações digitais. Estes experimentos desenvolvidos foram documentados e disponibilizados para os futuros alunos que desejarem utilizar este conhecimento no desenvolvimento dos seus projetos de Design.

Objetivos 1. Construir abstrações matemáticas a partir da observação das formas da natureza 2. Desenvolver desenhos criados a partir de linguagem de programação; 3. Estimular o uso de matemática e computação por Designers 4. Promover a aplicabilidade dos resultados no campo do Design

Metodologia O projeto de pesquisa foi desenvolvido a partir das etapas: (1) Leitura do livro; (2) Análise e fichamento dos capítulos; (3) Desenvolvimento de experimentos; (4) Organização didática dos experimentos; (5) Documentação dos experimentos.

Desenvolvimento “The goal of this book is simple. We want to take a look at something that naturally occurs in our physical world, then determine how we can write code to simulate that occurrence.1” Daniel Shiffman O livro The Nature of Code propõe um método de aprendizagem baseado na observação dos eventos que ocorrem naturalmente em nosso mundo para posteriormente simular estas ocorrências no ambiente de programação de software. A didática proposta por Shiffman no livro se mostra bastante eficaz, uma vez que o autor procura ensinar programação desde o conteúdo mais básico até o mais avançado. O livro é organizado de forma que o conteúdo apresentado em um capítulo é aproveitado pelo próximo, criando uma estrutura linear onde cada capítulo depende de uma base ensinada anteriormente.

1 "O objetivo deste livro é simples. Queremos dar uma olhada em algo que ocorre naturalmente em nosso mundo físico e, então, determinar como podemos escrever código para simular essa ocorrência. ” (Tradução nossa)


O livro começa com ensinamentos sobre a linguagem de programação Processing2, desenvolvida para facilitar o aprendizado de programação por designers, especificamente a função PVector que é utilizada ao longo de todo o livro. Na pesquisa, nos concentramos na leitura e estudo dos conteúdos considerados pelo autor como importantes para se obter um conhecimento sólido em Processing, e dos conceitos mais avançados de programação ensinados no final do livro. Iniciamos pelo estudo da função PVector, que foi essencial para a compreensão de estruturas de códigos que trabalham com movimentação complexa de objetos. Além disso, a função permite uma redução nas linhas de código por simplificar as variáveis utilizadas. Em seguida, a proposta do autor de representação de eventos e formas da natureza com a programação foi facilmente executada, uma vez que o estudo inicial da função PVector possibilitou a construção de movimentos fluidos e orgânicos, como os encontrados na natureza. Após o estudo de forças físicas aplicadas aos movimentos programados na etapa anterior, passamos ao estudo da classe de partículas para uma melhor compreensão de como gerenciar os objetos criados. Esses estudos possibilitaram a criação de grupos de objetos mais complexos, que normalmente afetam o desempenho do código, por terem uma enorme quantidade de objetos em cena. A última etapa da pesquisa focou na representação de organismos vivos e na simulação de uma inteligência artificial. Para tanto, foi necessário pensar em como não controlar os seres programados para que eles pudessem lidar com dificuldades, evoluir e encontrar um destino correto. A ideia desta pesquisa é tornar seus resultados um material livre e disponível para todos, ajudando desta forma designers e outros profissionais interessados na área de programação a compreender melhor os temas abordados. Além disso, espera-se que esse material possa ser usado em outros projetos, tendo em vista o caráter estético e funcional dos exemplos e experimentos desenvolvidos, que podem servir de base para a elaboração de códigos mais complexos. Por isso adotou-se a plataforma OpenProcessing3 para hospedar o estudo realizado. A plataforma se caracteriza como um ambiente que abriga trabalhos desenvolvidos em Processing por estudiosos da área. O conteúdo postado no site pode ser visualizado por outras pessoas que, de forma colaborativa, podem contribuir com seus conhecimentos e sugerir edições e até mesmo aprender e desenvolver outros projetos com base no conteúdo pesquisado no site.

A seguir, apresentamos aspectos de destaque identificados no estudo do livro, e alguns exemplos de aplicações no campo do Design que foram elaborados no decorrer da pesquisa:

a) Vetores como base de construção para a simulação de movimento no ambiente computacional

O livro ressalta o uso da função PVector, cujo objetivo é armazenar as coordenadas cartesianas x, y e z para o posicionamento e movimentação de um objeto no espaço virtual tridimensional. Essa característica permite armazenar de maneira simplificada a referência de posicionamento do objeto, tornando o código mais objetivo. Seguindo os ensinamentos do autor, a partir da observação de eventos da natureza, foram simulados no ambiente de programação múltiplos objetos com movimentação livre e com comportamentos únicos.

2 Processing: http://www.processing.org 3 https://www.openprocessing.org/


Os estudos de vetores levaram à elaboração de movimentos coordenados de grupos de objetos, de maneira similar a eventos da natureza: bandos de pássaros, ondas no mar, folhas ao vento, entre outros. Dando continuidade à pesquisa, foi estudado também o uso da função PVector para a simulação de forças físicas no ambiente de programação – por exemplo, a maneira como um objeto solto em um mundo ausente de forças se comporta na presença de gravidade. De uma maneira geral, o uso da função PVector foi utilizado para recriar movimentos similares aos presentes no mundo real regido pelas leis da Física.

Vetores "No campo da epidemiologia, um vector é utilizado para descrever um organismo que transmite uma infecção de um hospedeiro para outro." “Na Linguagem C++, vetor é uma implementação de uma estrutura de dados de matiz dinamicamente redimensionável.”

Para o autor "vector" refere-se a um vetor definido por uma entidade que possui tanto magnitude quanto direção. Usar a classe PVector simplifica o código e fornece um conjunto de funções para operações matemáticas comuns que acontecem uma vez ou outra durante o código.

- "Flexa" que liga 2 pontos (→) - Diferença entre 2 pontos - Função de armazenar 2 valores Usando vetores o código fica mais simples por ter menos variáveis. Por exemplo, em determinado código, as variáveis: float x; | float x = 100; float y; | float y = 200; float xspeed; | float xspeed = 1; float yspeed; | float yspeed = 1.33;

São substituídas por:

Vector location; | PVector location = new PVector(100, 200); Vector speed; | PVector velocity = new PVector(1, 1.3); A classe PVector armazena dois valores (ou 3 em um vetor 3D), descrevendo a posição do vetor no plano XY. Assim, é necessário se referir aos valores individuais de um vetor para descrever uma posição (x,y). A função ellipse(), por exemplo, não permite um vetor como argumento, logo não pode ser descrita da seguinte forma: ellipse (location, 16, 16); Ela só pode ser desenhada com dois valores escalares, uma coordenada x e uma coordenada y, usando componentes individuais de um PVector pela sintaxe de “ponto” (dot - orientada a objeto): PVector location; | location.x e location.y PVector velocity; | velocity.x e velocity.y Logo, a forma correta de desenhar a função ellipse() é:


ellipse( location.x, location.y, 16, 16);

Operações com vetores Operações com variáveis do tipo: x = x + xspeed; y = y + yspeed; Simplesmente não podem ser substituídas por: location = location + velocity; Na linguagem Processing, o sinal de adição “+” (ou outras operações) é reservado apenas para valores primitivos de variáveis, com int, float etc. Pela sintaxe, essa operação apenas é possível usando a função add(). Logo: location.add(velocity);

Estudo O código descreve a movimentação de uma grande quantidade de objetos controlados pelo ponteiro do mouse. A movimentação é feita no void update() através das operações com vetores. .sub() - subtrai valores; .normalize() - normaliza o vetor para um comprimento de unidade 1; .multi() - escala o vetor com multiplicação; .limit() - limita a magnitude de um vetor; velocity.limit( topspeed ); limita a magnitude de vetor Velocity pelo valor da variável topspeed. No void display() escrevo a função point() que é chamada no array. A grande quantidade de objetos resulta numa forma abstrata com movimentos leves e sincronizados, oscilando em torno do ponteiro do mouse.

Neste exemplo, grupos de esferas se movimentam livremente em uma área 3D (https://www.openprocessing.org/sketch/440961)


Na natureza existe um fenômeno muito similar a essa movimentação programada, chamado de “murmuração”, quando um enorme bando de estorninhos faz uma dança coletiva no céu com movimentos fluidos. Esse evento traduz uma certa conexão entre essas aves, uma vez que a auto-organização presente no bando nos faz ignorar a unidade (o pássaro) e passamos a enxergar o coletivo como a unidade, um organismo único.


Transição de cor RGB

A variação de cores presente no código é dada por uma função que escreve uma relação de seno do ângulo para valores de RBG.


float angle; angle += 0.02; fill( 1+127*sin(angle), 0, 255);

Enquanto green mantém seu valor em “0” e blue em “255”, red será acrescido em 0,02 a cada frame. Quando esse valor chegar a “255” o sinal da operação irá inverter(?) e o valor de red será subtraído 0,02 a cada frame, chegando a “0” e começando um novo ciclo.

Estudo inicial de vetores de força O objetivo deste estudo foi explorar como objetos de movimentação livre, soltos em um ambiente simulado ausente de forças da natureza, se comportam quando esse ambiente passa a recriar as forças físicas existentes no mundo real. Limitando uma certa área preenchida de gravidade, é possível simular esse comportamento físico nesses objetos. Optando por formas esféricas, foi aplicado um vetor de força e massa para simular leis da física. No exemplo, a simulação da segunda Lei de Newton (F = m * a) faz as esferas quicarem pela tela. Usando bibliotecas de programação, é possível simular uma câmera dentro desse ambiente, podendo mudar a forma de visualização desse evento, agora simulado dentro de um ambiente tridimensional.

https://www.openprocessing.org/sketch/440959


b) Partículas e programação orientada a objetos

Após a criação de grupos de objetos que seguem comportamentos particulares, o livro parte para dinâmicas mais avançadas de criação e controle destes objetos de forma independente: os Sistemas de Partículas. A partir do uso de programação orientada a objetos – onde múltiplos objetos podem ter comportamentos individualizados – foram obtidas variações na forma como os elementos surgem na cena, como eles desaparecem ou morrem, e como interagem uns com os outros. Novamente em uma análise voltada para a natureza, percebe-se a representação de comportamentos presentes em colônias de insetos, que têm a característica marcante de conexão entre indivíduos do grupo, como em uma trilha de formigas ou em um enxame de abelhas.

Um Sistema de Partículas se define com uma coleção de objetos independentes, que podem ser representados por uma forma ou apenas um ponto. Com esse tipo de estrutura é possível trabalhar com sistemas de múltiplos objetos e até mesmo com vários sistemas em apenas um código. Para o autor, sistemas de partículas são mais do que um simples código de caráter estético voltado para efeitos especiais. Eles simulam a complexidade de fenômenos comuns na natureza que dizem respeito a grupos específicos, como um bando de aves, ecossistemas em evolução e todas as coisas que trabalham no “plural”.

Logo, não é preciso se prender a uma classe que descreva apenas um objeto, mas sim a uma classe que descreva uma coleção de objetos, o próprio sistema de partículas. Isso torna possível uma abordagem mais sofisticada de programação orientada a objetos, como herança e polimorfismo. Estrutura básica ParticleSystem ps; void setup() { size(640,360); ps = new ParticleSystem(); } void draw() { background(255); ps.run(); }


Uma característica padrão de um sistema de partículas é seu EMISSOR, uma fonte que controla as configurações iniciais do sistema, como a localização, a velocidade etc. Ele pode emitir apenas uma partícula ou um fluxo contínuo de partículas.

Estudo de sistemas de partículas Mantendo a mesma estrutura dos estudos anteriores, um array com vários objetos oscilando ao redor do ponteiro do mouse (em programação de computadores, array se traduz como “arranjo”, uma estrutura de dados que armazena uma coleção de elementos de tal forma que cada um dos elementos possa ser identificado por, pelo menos, um índice ou uma chave), criamos um sistema de partículas simples, com apenas 1 partícula, descrita no void display() como uma elipse de raio 8px. ArrayList Sistemas de partículas também podem ter números fixos de objetos usando um Array. O autor ensina uma forma mais sofisticada para gerenciar as partículas, usando a classe Java ArrayList, que segue a mesma ideia do Array, mas com a sintaxe diferente.

Emissor contínuo (https://www.openprocessing.org/sketch/create)

Nesse exemplo, implementamos ao código anterior um emissor de partículas contínuo. Ainda há a interação das partículas com o mouse, porém essas partículas nascem de um emissor pontual fixo na tela descrito por:

particles.add(new Particle(new PVector(width/2, 50)));

Onde novas partículas são adicionadas ao ArrayList a cada ciclo por meio de um vetor deposições x = width/2 e y = 50.

Ao observar um emissor contínuo de partículas, percebe-se que, na medida em que novas partículas nascem, o desempenho do código acaba diminuindo, tornando-se mais lento. Isso se deve ao fato de que essas partículas têm um tempo de vida infinito, armazenando informação a cada frame e consequentemente deixando o código mais lento.

print


Declarando a função “frameRate(60); ”( 60fps) e a função “println( frameRate);” percebe-se que a taxa de fps decai ao longo do tempo.

Para isso, é preciso criar uma função que trabalhe com o tempo de vida das partículas, ditando quando e como elas irão morrer. Uma maneira simples de trabalhar com a vida de uma partícula é usando sua opacidade.

Estudo do tempo de vida da partícula

O que foi experimentado: Em class Particle{} criamos a variável lifespan e dizemos que seu valor inicial é 255. No void update() dizemos que o valor de lifespan será subtraído em 1.0 a cada frame (lifespan -= 1; ). Usando a função point() neste estudo, preenchemos seu stroke com 255 (branco) e lifespan como opacidade. A partícula é deletada quando o valor de lifespan for inferior a 0, que por sua vez é verificado pela variável boolean isDead() como verdadeiro ou falso. Isso é acessado no void draw(), e caso verdadeiro, a função .remove() deleta a partícula. Mudando a forma do emissor, agora as partículas nascem de forma randômica pela tela. Sem o acúmulo de informações, as partículas com opacidade inferior a zero são deletadas, e assim, tanto a taxa de fps quanto o desempenho do programa se mantêm estáveis. Os objetos que vão morrendo perdem sua cor até desaparecerem.


(https://www.openprocessing.org/sketch/440958)



Esses experimentos tiveram como característica principal o estudo da classe de partículas, possibilitando um melhor desempenho do processamento de dados em códigos muito pesados.

Os movimentos simulados pelos experimentos focaram na representação de movimentos similares aos encontrados na natureza, como por exemplo o movimento de grupos de insetos voadores. Abelhas em suas comunidades, ao se depararem com uma situação de perigo, procuram voar em um grupo concentrado para atacar, formando uma nuvem. Aprimorando a estética dos experimentos, foi trabalhado um sistema de texturas de baixa opacidade para produção de um brilho em cada partícula. Esse brilho tem uma oscilação de cores e é mesclado entre si pela função blendMode().

A textura foi criada no software Adobe Photoshop, trata-se se um disco branco com as bordas suavizadas devido a uma variação de transparência do centro opaco para a extremidade. Essa característica permite sobreposições dessa imagem de modo que o resultado seja uma grande mancha.


(https://www.openprocessing.org/sketch/440963) Os movimentos criados neste experimento tiveram aspecto de vida. Como um organismo vivo, um verme, nascendo e se movimentando de maneira livre.


c) Comportamento e inteligência

Em seguida, foi estudado o conteúdo de algoritmos genéticos (Genetic Algorithms, ou GAs), aplicados à construção de comportamentos e inteligência. Com base nos princípios Darwinianos de Hereditariedade, Variação Genética e Seleção Natural, emergem possibilidades de programação de objetos computacionais com inteligência própria, capazes de aprenderem e atingirem objetivos, assim como fazem os seres vivos existentes no mundo natural.

A evolução do código “O fato de que a vida evoluiu de quase nada, cerca de 10 bilhões de anos depois que o universo evoluiu literalmente de nada, é um fato tão assombroso que eu estaria louco de tentar explicar com palavras."

Richard Dawkins

Iniciamos esta etapa do estudo buscando definições e conceitos de algoritmo: “Conjunto de regras necessárias para resolução de um problema ou cálculo; processo computacional bem definido, baseado num conjunto de regras, finito, que executa uma determinada tarefa.

No livro The Nature of Code, o capítulo The Evolution of Code é dedicado ao estudo dos princípios fundamentais por trás da teoria da evolução darwiniana e do desenvolvimento


de um conjunto de algoritmos inspirados por estes princípios, que são aplicados a estratégias evolutivas em softwares. A seguir trazemos as principais questões estudadas no capítulo, que nortearam os experimentos finais desenvolvidos em nossa pesquisa

Algoritmo Genético Tradicional (GA)

Este tipo de algoritmo foi desenvolvido para resolver problemas em que o espaço de solução é tão vasto que um algoritmo de "força bruta" simplesmente levaria muito tempo para resolvê-lo.

O autor exemplifica esse algoritmo com uma questão de adivinhação: Estou pensando em um número entre um e um bilhão. Quanto tempo levará para você adivinhar esse número?

Resolver um problema com "força bruta", refere-se ao processo de verificação de todas as soluções possíveis. É o número um? É o dois? É o três? É o quatro? E assim por diante. Embora a sorte desempenhe aqui um fator, com força bruta poder-se-ia ficar esperando por anos até que a pessoa acertasse o número exato. No entanto, e se fosse possível dizer se uma resposta dada foi boa ou ruim? Quente ou fria? Muito quente? Quente? Super, super fria? Se a pessoa pudesse avaliar como "ajustar" uma suposição/adivinhação, poderia escolher outros números mais próximos de suas apostas e chegar à resposta correta mais rapidamente. A resposta poderia evoluir.

Seleção Natural Darwiniana Para que uma seleção natural ocorra, como acontece na natureza, todos os três elementos descritos abaixo deverão estar presentes. No processo de implementação de simulações que venham a ser planejadas a partir de algoritmos genéticos, esses três princípios fundamentais da evolução darwiniana são necessários:

Hereditariedade Se as criaturas vivem tempo suficiente para se reproduzir, seus traços são transmitidos

aos filhos na próxima geração de criaturas. Variação

Deve haver uma variedade de traços presentes na população ou um meio com o qual introduzir variação, caso contrário não há evolução.

Por exemplo: uma população de besouros em que todos os besouros são exatamente iguais (mesma cor, mesmo tamanho, mesma envergadura). Sem qualquer variedade na população, os descendentes serão sempre idênticos aos pais e uns aos outros. Novas combinações de traços não podem ocorrer e nada pode evoluir.

Seleção Deve haver um mecanismo pelo qual alguns membros de uma população tenham a

oportunidade de ser pais e de transmitir a sua informação genética, e outros não. Isto é tipicamente referido como "sobrevivência do mais apto".

A seleção natural opera com base no princípio de que alguns traços são melhor adaptados para o ambiente da criatura e, portanto, produz uma maior probabilidade de sobrevivência e reprodução.


Criando uma população – reprodução Estrutura do código Setup

Passo 1: Inicializar. Criar uma população de N elementos, cada um com DNA gerado aleatoriamente. Loop Passo 2: Selecionar. Avaliar a aptidão de cada elemento da população e criar um pool de acasalamento. Passo 3: Reproduzir. Repetir N vezes: A) Escolha dois pais com probabilidade de acordo com a forma física relativa. B) Crossover - crie um "filho" combinando o DNA desses dois pais. C) Mutação - mate o DNA da criança com base em uma dada probabilidade. D) Adicione o novo filho a uma nova população.

Passo 4: Substituir a população antiga pela nova população e regressar ao Passo 2.

Crossover envolve a criação de um ser a partir da permutação do código genético dos pais. Essa criação é dada de forma aleatória, utilizando 50% dos dados dos pais. Como exemplificado no livro, o cruzamento de pais hipotéticos “FORK” e “PLAY” (o autor utiliza palavras com 4 letras para explicar o cruzamento de 50%), resulta em um filho “FOAY”, da combinação de 2 letras de cada um, por exemplo. Na etapa de Seleção - função Fitness - o algoritmo busca selecionar em um determinado grupo de “indivíduos” (objetos) sua aptidão física, ou seja, aqueles que estarão aptos para dar origem a uma nova geração. Para isso, é necessário criar um alvo que serve como seletor de aptidão para o acasalamento. Esse alvo é determinado no código e funciona como um objetivo a ser alcançado. Por exemplo: se meu critério de reprodução é o objeto que mais se movimentou no eixo Y - plano cartesiano - a função fitness dará conta de verificar essa informação.

A reprodução é acompanhada de uma determinada taxa de mutação, bem como do princípio darwiniano de variação. Essa taxa normalmente é pequena e permite introduzir uma variedade adicional ao longo do próprio processo evolutivo.

Uma taxa de mutação alta pode afetar consideravelmente o comportamento do sistema, impedindo que ocorra o próprio processo evolutivo, uma vez que as próximas gerações não guardam as informações necessárias para que haja a evolução no código.

Pela estrutura do algoritmo genético há sempre o processo de seleção que escolhe os pais e o processo de reprodução, onde há o cruzamento e a mutação. Na etapa seguinte, uma nova população é criada, e mais uma vez ocorre a avaliação da aptidão física para realizar a seleção e a reprodução novamente.

O estudo passo a passo foi importante para o entendimento de como uma programação de objetos computacionais com inteligência própria, capazes de aprenderem e atingirem seus objetivos, era possível. Mas não bastava entender. Como designers, profissionais sempre envolvidos com a visualização/ materialização de ideias, era para nós importante poder representar/visualizar o que tinha sido estudado e aprendido.


Juntando então, conhecimentos da área de design em relação a cor no ambiente digital (escala RGB), animação, princípios de jogos e código criativo elaboramos uma simulação na qual os princípios evolutivos pudessem ser visualizados e experimentados. Imaginamos então um cenário de comunidades de insetos em constante movimento.

Experimento 1 - Genética/ Reprodução (https://www.openprocessing.org/sketch/439712)

Nesse experimento, grupos de insetos de diferentes cores (a partir de valores RGB) e movimentação aleatória são criados em um ambiente. No cruzamento desses seres, há a soma de seus valores RGB e, consequentemente, a próxima geração de insetos tem cores diferentes resultantes desse processo. Cada geração de indivíduos tem um certo tempo de vida para que uma nova geração seja criada. Durante esse tempo, todos os seres podem gerar descendentes, seguidos de um certo valor de mutação, porém somente aqueles que têm aptidão física (fitness) alta são selecionados como pais para dar origem a uma nova geração. A aptidão física (fitness), neste caso, se manifesta e é evidenciada naquele indivíduo que chega mais perto do alvo. Aqueles que têm uma aptidão muito baixa não são selecionados para a etapa de reprodução.

void fitness() { float d = dist(location.x, location.y, target.x, target.y); fitness = pow(1/d, 2); } Como é preciso selecionar aqueles que têm maior valor de fitness, a relação fica: fitness = pow(1/d, 2) Assim, FITNESS será 1 dividido pela distância. Para valores altos, como 200, fitness será 0,005. Uma distância grande para um valor de aptidão física muito baixo.


Nesse momento percebe-se insetos próximos ao alvo (elipse preta no centro da tela), onde o inseto roxo está mais próximo, seguido do azul e do verde, considerando-se suas distâncias em relação ao alvo.

Na próxima geração, já se pode perceber novas cores de insetos, como um roxo mais azulado, um azul esverdeado e até mesmo um tom mais rosado, originado através do valor da mutação.


Como resultado, nas inúmeras reproduções que irão ocorrer, a tendência é o surgimento de insetos com cores e movimentos iguais sem nenhum tipo de variação. Nesse caso, o processo evolutivo do código tende a estagnar.

Experimento 2 - Inteligência (https://www.openprocessing.org/sketch/439915)

Neste experimento, colocamos barreiras que dificultam os movimentos livres dos insetos e acabam impedindo que eles cheguem no seu destino, o alvo. Porém, uma classe no código foi criada para verificar se o inseto colidiu com a barreira. Caso tenha ocorrido a colisão, uma outra função passa a impedir que o algoritmo atualize as informações de localização nas próximas gerações. Considerando que o objetivo deste experimento foi fazer com que os insetos chegassem a seu destino, foi necessário trabalhar na função fitness penalizando os insetos que colidiam com as barreiras e recompensando aqueles que chegavam mais perto do alvo, em qualquer ponto do ambiente. Os insetos que colidiam tiveram seu valor de fitness reduzido expressivamente e os que chegavam mais perto, seu valor de fitness foi multiplicado por 2. Como foi impossibilitado aos objetos atualizarem suas informações caso colidissem, o algoritmo evoluiu para que os insetos, nas gerações futuras, pudessem alcançar seu objetivo sem colidir com a barreira que dificulta essa tarefa. As barreiras, juntamente com a penalidade no valor de fitness, serviram como um seletor natural, fazendo com que somente os mais fortes, nesse caso aqueles que chegaram mais longe e (ou) mais perto do alvo, estivessem aptos a dar origem a novas gerações de indivíduos virtuais. No início os insetos são criados e se movimentam em direções variadas. Nesta etapa, já ocorrem colisões que quebram sua aptidão física e a seleção daquele que andou mais rápido e chegou mais próximo ao destino acontece.


Na quinta geração percebe-se uma concentração de insetos seguindo um mesmo caminho e um grupo menor seguindo um caminho contrário - mutação.


Na oitava geração, os insetos já estão chegando próximos ao destino final.

Na geração 28, mesmo com as barreiras, os insetos já conseguem chegar a seus destinos.



Experimento 3 – Função FITNESS

Função FITNESS - estrutura

void fitness() { if (recordDist < 1) recordDist = 1; // Recompensa terminando mais rápido e chegando perto fitness = (1/(finishTime*recordDist)); fitness = pow(fitness, 4); if (hitObstacle) fitness *= 0.1; // Perde 90% de aptidão atingindo um obstáculo if (hitTarget) fitness *= 2; // Duas vezes a aptidão if (location.x < 0 && location.x > width) { fitness *= 0.1; } if (location.y < 0 && location.y > height) { fitness *= 0.1; } }

Determinando uma “punição” para os insetos que saíssem da área, estabelecemos que o fitness nesses casos seria reduzido em 90%. Isso fez com que, ao término do tempo de vida, os insetos que permanecessem dentro do limite da tela mantivessem sua taxa de aptidão física sem alteração, ou seja, tivessem mais chances de serem escolhidos como os pais da próxima geração. Isso reduziu a quantidade de cruzamentos entre os tipos diferentes de insetos que resultavam numa grande variedade de cores. Como os insetos roxos, em sua maioria, permaneceram na área sem ultrapassar os limites, houve um processo de reprodução entre essa cor e algumas restantes.


Conclusão

Os objetivos propostos nessa pesquisa, de construção de abstrações matemáticas a partir da observação das formas da natureza; desenvolvimento de desenhos criados a partir de linguagem de programação; estímulo do uso de matemática e computação por Designers; e promoção de aplicabilidade dos resultados no campo do Design, tendo como referência o livro The Nature of Code de Daniel Shiffman, foram alcançados integralmente. O estudo de Algoritmos Genéticos trouxe um grande foco no campo da Biologia, mais especificamente no estudo da genética e seleção natural de organismos, com base nos princípios de Charles Darwin. Na pesquisa, buscamos dar visibilidade a um evento fortemente presente na natureza, a evolução, elaborando uma representação bastante fiel ao que acontece. O princípio básico de seleção natural tem seu foco no fato de que características favoráveis à manutenção da espécie, que são hereditárias, tornam-se mais comuns em gerações sucessivas de uma população de organismos que se reproduzem, e que as características desfavoráveis, que também são hereditárias, tornam-se cada vez menos comuns, indicando um processo de seleção natural. Como foi apresentado no conteúdo do livro, o algoritmo foi capaz de ditar regras para os objetos e, por meio de informações armazenadas por eles, no processo de reprodução entre si para gerar descendentes ao término de uma vida útil, essas informações foram transmitidas. Podemos, portanto, fazer uma analogia entre o processo de reprodução descrito e o que acontece no mundo real, onde criaturas se reproduzem e as novas gerações carregam traços genéticos de seus antecedentes. Enquanto uma variedade grande de indivíduos gera uma boa variedade de descendentes, uma pequena variedade tende a gerar indivíduos mais semelhantes entre si, que no futuro tendem a ser todos iguais. Um outro aspecto importante do algoritmo foi a seleção natural. Nesse caso, foram definidas regras que impossibilitavam os objetos (seres) de se reproduzirem caso eles fizessem alguma atividade considerada negativa, como por exemplo ultrapassar certos limites ou colidir com alguma coisa. Além disso, os objetos eram recompensados caso fizessem algo positivo, como conseguir chegar mais longe e mais ainda se chegassem perto de seu objetivo. Com isso, as gerações futuras aprendiam com os erros de seus “pais” e armazenavam os pontos positivos para conseguir atingir seus objetivos.

Os experimentos desenvolvidos conseguiram explorar o grande potencial do Algoritmo Genético para simulação de vida e inteligência artificial, uma vez que as séries de programas conseguem atingir um objetivo, lidando com erros e acertos. A partir dos resultados obtidos, concluímos que o estudo de programação de computadores por designers aliado à interpretação e representação dos eventos da natureza geram resultados que podem ser utilizados em projetos de design – seja pelo caráter estético desses resultados como também pelo seu caráter funcional. Os exemplos gerados a partir do desenvolvimento deste projeto são um recurso didático disponível a todos os designers que desejarem compreender e representar as formas, movimentos e comportamentos do mundo natural. Bibliografia SHIFFMAN, Daniel. Learning Processing: A Beginner’s Guide to Programming Images, Animation, and Interaction. Second Edition. New York: Elsevier, 2015.


__________The Nature of Code: Simulating Natural Systems with Processing. New York: Nature of Code, 2012. REAS, Casey e FRY, Ben. Processing: a Programming Handbook for Visual Designers and Artists. Cambridge: MIT Press, 2007.

design a partir de formas da natureza: … · vector speed; | pvector velocity = new pvector(1,...

Documents