terça-feira, 14 de abril de 2015

M.A.M.I. Trabalho 01: Análise matemática de uma obra artística ou peça de design e aplicação do conceito.

O Conjunto de Mandelbrot
É basicamente um fractal definido como um conjunto de pontos c no plano complexo para o qual a sucessão definida recursivamente:

z_0 = 0\,
z_{n+1} = {z_n}^2 + c
não tende ao infinito.
Para cada ponto c do plano complexo, a sequência se expande como:
c=x+iy \,
Z_0=0 \,
\begin{matrix}Z_1&=&Z_0^2+c \\ \ &=& x+iy\end{matrix} \,
\begin{matrix}Z_2&=&Z_1^2+c \\ \ 
&=&(x + iy)^2+x+iy \\ \ 
&=&x^2+2ixy-y^2+x+iy \\ \ &=&x^2-y^2+x+(2xy+y)i\end{matrix} \,
Z_3=Z_2^2+c=... \,
e assim por diante.

Escolha da análise matemática envolvida:
Decidi focar o conceito de "recursividade" envolvido para recriar uma aplicação baseada nele, que agisse de maneira similar ao Conjunto de Mandelbrot, em outras palavras, o uso de Fractais.
- Conceito de recursividade: É um termo usado de maneira mais geral para descrever o processo de repetição de um objeto de um jeito similar ao que já fora mostrado. Um bom exemplo disso são as imagens repetidas que aparecem quando dois espelhos são apontados um para o outro. Em ciência da computação, a recursividade é a definição de uma subrotina (função ou método) que pode invocar a si mesma. Um exemplo de aplicação da recursividade pode ser encontrado nos analisadores sintáticos recursivos para linguagens de programação. A grande vantagem da recursão está na possibilidade de usar um programa de computador finito para definir, analisar ou produzir um estoque potencialmente infinito de sentenças, designs ou outros dados.
- Conceito de Fractal:É um objeto geométrico que pode ser dividido em partes, cada uma das quais semelhante ao objeto original. Diz-se que os fractais têm infinitos detalhes, são geralmente autossimilares e independem de escala. Em muitos casos um fractal pode ser gerado por um padrão repetido, tipicamente um processo recorrente ou iterativo.
Então, baseado nestas definições, a aplicação a ser criada deverá ser um fractal gerado por uma função que chama a si mesma sucessivamente, gerando na tela, sob uma certa condição, uma repetição do mesmo efeito.

O livro "The Nature of Code", de Daniel Shiffman, fala sobre a implementação de diversos fractais.

Site com exemplos de fractais:http://andrew-hoyer.com/experiments/fractals/
 
Fontes: site Wikipédia
The Nature of Code(Shiffman, Daniel.)

Aplicação:
A função criada, no momento que o mouse é pressionado. gera um círculo central, com outros círculos menores a sua volta, e dependendo da direção que o mouse é arrastado irão gerar mais ou menos imagens correspondentes.

Código:

//Fractal com recursividade
boolean mousePressed = false;
void setup() {
  size(800,500);
}

void mousePressed() {
  mousePressed = !mousePressed; //Alterna o valor da variável mousePressed entre true e false
}

void draw() {
  background(255);
  drawCircle(mouseX, mouseY, 200);
}

void drawCircle(float x, float y, float radius) {
  fill(255);
  //Desenha elipse
  ellipse(x, y, radius, radius); //Desenha uma elipse central 
  if (radius > 8) { //Enquanto radius não for menor do que 8 executa recursivamente o método drawCircle
    drawCircle(x + radius/2, y, radius/2 - ((mousePressed ? mouseY : mouseX) * 0.1)); //Desenha uma elipse
                                                            // na borda direita do círculo central com
                                                            // o tamanho sendo:
                                                            //   (metade do radius do círculo original)
                                                            // - (10% da posição X ou posiçao Y do mouse)
    drawCircle(x - radius/2, y, radius/2); //Desenha uma elipse na borda esquerda do círculo central
    drawCircle(x, y + radius/2, radius/2); //Desenha um círculo na parte superior do círculo central
    drawCircle(x, y - radius/2, radius/2); //Desenha um circulo na parte inferior do círculo central
  }
  drawMousePosition(); //Mostra a posiçao X e Y atual do mouse
}

void drawMousePosition() {
  fill(0);
  text("Posiçao X do mouse = " + mouseX + "", 10, 15);
  text("Posiçao Y do mouse = " + mouseY + "", 10, 30);
}

Resultados:




segunda-feira, 13 de abril de 2015

Processing: Bandeira do Brasil

O objetivo era criar uma função que desenhasse a bandeira do Brasil de acordo com a Lei federal N° 5.700. Não consegui acrescentar a faixa, estrelas e texto ainda.

As regras são:

Art. 5º A feitura da Bandeira Nacional obedecerá às seguintes regras (Anexo nº 2):
I - Para cálculo das dimensões, tomar-se-á por base a largura desejada, dividindo-se esta em 14 (quatorze) partes iguais. Cada uma das partes será considerada uma medida ou módulo.
II - O comprimento será de vinte módulos (20M).
III - A distância dos vértices do losango amarelo ao quadro externo será de um módulo e sete décimos (1,7M).
IV - O círculo azul no meio do losango amarelo terá o raio de três módulos e meio (3,5M)..

Análise das regras:



















Código:

int x= 30;
void setup (){
 int x= 30;
  size (20*x, 14*x);
  background (#00A201);
  mostraBrFlag();
}

void mostraBrFlag(){
   noStroke();
   fill (#F7F714);
   quad (1.7*x,7*x, 10*x, 1.7*x, 18.3*x, 7*x, 10*x, 12.3*x);
   fill (#0039C6);
   ellipse ( 10*x, 7*x, 7*x,7*x); 
}

Resultado:


Processing: Rastro da Trajetória

Peguei o código de simulador de lançamento balístico criado em sala de aula e apenas removi o background do "draw" para que a trajetória da bola permanecesse apresentada na tela.

Código:

float dx;
float dy = 600;
float t = 0;
float v0x = 30;
float v0y = 100;
float ax = 0;
float ay = -10;
float vx;
float vy;
float v;

void setup() {
  size(800,600);
  background(0);
  frameRate(1);  
}

void draw() {
  moveBolaMRUV();
  t++;
}

void moveBolaMRUV() {
  dx = (v0x*t) + ax*(t*t)/2;
  dy = (v0y*t) + (ay*(t*t))/2;
  vy = v0y + ay*t;
  v = (v0x+v0y)/2;
  ellipse (dx, height - dy, 20, 20);
}

Resultado:


Processing: Deslocamento e Tempo

Foi pedido que modificasse um simulador que mostrasse em quanto tempo um corpo à 30m/s percorria uma distancia de 800 metros.
As modificações feitas foram: Aumentar o tamanho da tela no eixo X para 900 metros, assim seria visível o momento que o objeto passaria pelo ponto de 800 metros. Demarcar com linhas espaçadas de 100 em 100 metros para uma melhor visualização. E com o uso da ferramenta "text" apresentar na tela os valores de tempo e distância percorrida pelo objeto.
O objeto alcançará a distância de 800 metros em aproximadamente 28 segundos.

Código:

int d;
int v = 30;
int t = 0;

void setup() {
  background(0);
  size(900, 600);  
  frameRate(1);  
}

void draw() {
  background(0);
  for(int i = 0; i < 9; i++){
  line(i * 100, 0, i * 100, 900);
  stroke(45);
  fill(255);
 }
  println(t, 20,20);
  moveBolaMRU();
  t++;
  text("Tempo: " + t + " seg", 20, 20);
  text("Distância: " + d + " m", 20, 35);
}

void moveBolaMRU() {
  d = v * t;
  println(d);
  ellipse(d, 300, 10, 10);
}

Resultado:


domingo, 12 de abril de 2015

Processing: Exercício de Funções(Flor)

Foram criadas duas funções dentro do programa. A primeira, função, circulo(int x, int y, int r), desenha um círculo qualquer na tela e era chamada na segunda função, flor2(int x, int y, int r), onde, sempre que o mouse for pressionado, são desenhados cinco círculos agrumados em formato de flor, com as pétalas dispostas em diagonal em relação ao centro do desenho, tendo o círculo central gerado no ponto onde o cursor do mouse for pressionado, e com cores aleatórias modificadas à cada clique.

Código:

void setup(){
  size(300,300);
  noStroke();
  background(0);
  frameRate(10);
  }

void circulo(int x,int y, int r){
 
  ellipse(x,y,2*r,2*r);
}

void flor2(int x, int y, int r){
  fill(random(255),random(255),random(255));
  circulo(x,y,r);
 fill(random(255),random(255),random(255));
  circulo(x-(r+(r/2)),y+(r+(r/2)),r);
  circulo(x+(r+(r/2)),y-(r+(r/2)),r);
  circulo(x-(r+(r/2)),y-(r+(r/2)),r);
  circulo(x+(r+(r/2)),y+(r+(r/2)),r);

}

void draw(){
  if(mousePressed == true){
  background(0);
      flor2(mouseX,mouseY, 30);
  }
 
 }

Resultado:


Processing: Exibindo valores na tela

O código seguinte gera uma simulação de lançamento balístico e exibe na tela, com o uso da ferramenta "text", os valores das variáveis envolvidas na simulação.

Código:

float dx;
float dy = 600;
float t = 0;
float v0x = 30;
float v0y = 100;
float ax = 0;
float ay = -10;
float vx;
float vy;
float v;

void setup() {
  size(600,600);
  background(0);
  frameRate(1);
  }  
}

void draw() {
  background(0);
  moveBolaMRUV();
  t++;
  text("Tempo:" + t, 20, 20);
  text("Veloc.:" + v, 20, 35);
  text("D.Hori.:" + dx, 20, 50);
  text("D.Vert.:" + dy, 20, 65);
}

void moveBolaMRUV() {
  dx = (v0x*t) + ax*(t*t)/2;
  dy = (v0y*t) + (ay*(t*t))/2;
  vy = v0y + ay*t;
  v = (v0x+v0y)/2;
  ellipse (dx, height - dy, 20, 20);
}

Resultado:

Processing: Exemplo

Neste exemplo do site https://processing.org/examples vemos um código que gera linhas horizontais e verticais que se entrelaçam formando uma malha na tela. A partir do código dado modifiquei o tamanho da tela, os valores de espaçamento entre as linhas e as cores de background edas linhas geradas.

Código original:

void setup() {
  size(640, 360);
}

void draw() {
  background(127);
  noStroke();
  for (int i = 0; i < height; i += 20) {
    fill(129, 206, 15);
    rect(0, i, width, 10);
    fill(255);
    rect(i, 0, 10, height);
  }
}
Resultado:














Código alterado:

void setup() {
  size(800, 600);
}

void draw() {
  background(0);
  noStroke();
  for (int i = 0; i < height; i += 50) {
    fill(0, 193, 56);
    rect(0, i, width, 10);
    fill(59, 84, 165);
    rect(i, 0, 10, height);
  }
}

Resultado: