Davi no SMD: abril 2014

segunda-feira, 28 de abril de 2014

Lançamento balistico utilizando ângulos

Exercício proposto para criação de uma função que receba como parâmetro um ângulo e a velocidade do disparo.

Print de um instante de execução do código

int relogio = millis();
int intervalo = 1000;
float dx;
float dy = 600;

float t;

ArrayList pontos = new ArrayList();

void setup()
{
   size(600,600);
  background(100); 
}

void draw()
{
  t = millis()/100; //contador de tempo
  disparoBalistico(70,100);
  desenhaTrajeto(pontos);
  
}


void disparoBalistico(int ang, int velLancamento)
{
  /*
  Essa função funciona a partir da decomposição dos vetores de movimento
  o Vo da formula é o valor velLancamento, passado por parametro.
  O V utilizado no dx é o resultado da decomposição do eixo X do vetor de movimentação
           |  /
V do MRUV  | /  a linha de / = resultante do vetor, ou hipotenusa, responsável pela direção do projétil
           |/___
            Velocidade do MRU
     eixo y = hipotenusa * seno(angulo)
     eixo x = hipotenusa * cos(angulo)     
  */
  background(100);
  float a = -9.8; //declaro a aceleração, uma CONSTANTE.
  float hipo = velLancamento/sin(radians(ang)); // descubro o valor da hipotenusa, necessária para descobrir o eixo X do vetor
  float velFixo = hipo * cos(radians(ang)); //Descubro o eixo X do vetor.
  //A partir daqui é apenas aplicação de formula.
 pontos.add(dx);    //pontos utilizados para a função desenhaTrajeto.
 pontos.add(dy+600);
 dx = velFixo*t;
 dy = (velLancamento*t + (a*t*t/2))*-1;
 pontos.add(dx);
 pontos.add(dy+600);
 ellipse(dx,600 + dy, 30,30);
 
}

void desenhaTrajeto(ArrayList pontos)
{
 for(int i = 3; i < pontos.size(); i+=2)
{
   line((Float)pontos.get(i-3),(Float)pontos.get(i-2),(Float)pontos.get(i-1),(Float)pontos.get(i));
   
} 
}

Cortando pizzas

Exercício que propõe a divisão de uma esfera em um número de fatias informadas no parametro da função.

void setup()
{
  size(600,600);
  
  desenhaPizza(6);
  
    
}

void desenhaPizza(int n)
{
  int inc = 360/n;
  for(int i = 0; i <= 360; i += inc)
  {
   arc(300,300,250,250,radians(i),radians(i+inc),PIE); 
  }
    
}

Desenho de quadrados

Exercício que propõe a criação de uma função que desenhe um quadrado.

Resultado do código abaixo

void setup()
{
  size(600,600);
  
  desenhaQuad(10,10,20,20);
  
    
}

void desenhaQuad(int x1,int y1 ,int x2,int y2)
{
  line(x1,y1,x1,y2);
  line(x1,y2,x2,y2);
  line(x2,y2,x2,y1);
  line(x2,y1,x1,y1);
}

Desenhando o Yin Yang

Exercício para utilizar a criação de imagens através da junção de formas geométricas.

Resultado do código abaixo.

void setup ()
{
  size (500, 500);
  mostraYinYang(250, 250, 90);
}

void mostraYinYang (float x, float y, float r)
{
  fill (0);
  ellipse(x, y, 5*r, 5*r); //faz a elipse preta
  fill(255);
  arc(x,y,5*r,5*r,0,PI,OPEN); //faz um meio arco aberto no meio da elipse preta
  noStroke(); //sem linha
  ellipse(x - r-r/4, y, 2.5*r, 2.5*r); // faz a esfera menor do lado esquerdo de acordo com um raio
  fill(0);  
  ellipse(x + r+r/4, y, 2.5*r, 2.5*r); // faz a esfera menor do lado direito de acordo com o raio
  fill(255);
  ellipse(x + r+r/4, y, r, r); //faz a esferinha pequena dentro da esfera menor direita 
  fill(0);
  ellipse(x - r-r/4, y, r, r); //faz a esferinha pequena dentro da esfera menor esquerda 
}

Halftone vertical

Continuação da aula de estruturas de repetição para criação de efeitos visuais.

Resultado do código abaixo.

void setup () {
  size (400, 400);
}

void draw () {
  background (255);
  int largura = 1;
  for (int j = 0; j < 400; j += 40) //espaçamento vertical das elipses
  {
    largura = largura + 5; // a largura aumenta 5 a cada elipse
    for (int i = 0; i< 400; i += 40) //espaçamento horizontal das elipses
    {
      ellipse(i + 20, j+ 20, largura, largura);
      stroke (mouseX * mouseY, mouseY- mouseX, mouseX+mouseY); //retira a linha das elipses
      fill (mouseX * mouseY, mouseY- mouseX, mouseX+mouseY); //colore as elipses
    }
  }
}

Efeito Halftone central

Objectivo desse exercício é utilizar estruturas de repetição (for) para criação de efeitos visuais.

Resultado do código abaixo.

int largura = 400;
int altura = 400;

void setup ()
{ 
  size (largura, altura);
  background(0);
  Grid();
}

void Grid() {
  for (int i = 0; i < largura; i+=30) 
  {
    for (int j = 0; j < altura; j+=30)
    {
      float d = dist (i, j, largura/2, altura/2)/10;// d = distância entre pontos
      stroke (255);
      ellipse ( i + 10, j + 10, d*2, d*2);
    }
  }
}

Tabuleiro de xadrez

Exercício para criar o desenho de um tabuleiro de xadrez.

Resultado do código abaixo.

int x = 400;
int y = 400;
int cor = 1;
int largura = 40;
int altura = 40;

void setup()
{
  size(400, 400);
  background(255); //branco
  fill(0); //roxo
}

void draw() 
{
  for (y=0; y<=400; y+=80) //laço para fazer as colunas coloridas intercaladas
  {
      for (x=0; x<400; x+=80) {
        rect(x, y, largura, altura);
        rect(x+40, y+40, largura, altura);
      } 
  }
}

Uso de MRUV horizontal

O exercício aqui foi fazer um código que informasse na tela e no console em qual instante t, a bola alcança a distancia de 123 metros.

int largura=800; 
int altura=800; 
int relogio; 
int intervalo=100; 
float d = 0; 
float v=0; 
float vIni= 0;
float t=0;  
float a=10; 
boolean printou;


void setup() { 
  relogio=millis(); 
  size(largura, altura);
} 
void draw() { 
  if (millis()>relogio+intervalo) { 
    relogio=millis(); 
    background(125); 
    linhas(); 
    moveBolaMRUV(); 
    t+= 0.1;
    if(d <= 0)
    {
     println(t); 
    }
  }
} 
void moveBolaMRUV() { 
  d=vIni*t + (a*t*t)/2;  
  ellipse(d, 400, 25, 25);
  
  textSize(30);
  text("Distância: "+d, 300,200);
  text("Tempo: "+t, 300,250);
  if(d >= 123 && !printou)
  {
     println("Distancia é 123 e o tempo é: " + t );
    printou = true; 
  }
}

Criando n poligonos regulares

Esse exercício é criar uma função onde seja possível desenhar um polígono regular no centro da tela e com a quantidade de lados que seja desejado.

int largura = 500;    //largura da tela
int altura = 500;     //altura da tela
void setup()
{
   size(largura,altura);
  desenhaForma(150,200); 
}


void draw()
{
  
 
}
//Função que retorna o eixo x de uma coordenada polar em relação an centro da tela
float polarX(float angulo, float raio)
{
  
  float x = raio * (cos(radians(angulo)));
  return x + largura/2;
}

//Função que retorna o eixo y de uma coordenada polar em relação an centro da tela
float polarY(float angulo, float raio)
{
 float y = raio * (sin(radians(angulo))); 
 return y + altura/2;
}


//Função que desenha os lados dos poligonos utlizando o valor retornado pelas funções polarX e polarY
void desenhaForma(int numLado,int raio)
{
  //incremento é o intervalo em angulos das "fatias" do poligono
  float incremento = 360/numLado;
  for(int i = 0; i < 360; i+=incremento)
  {
    line(polarX(i,raio),polarY(i,raio),polarX(i+incremento, raio),polarY(i+incremento, raio));   
  }
}

O exercício aqui foi o uso de coordenadas polares e controle de tempo afim de criar um relógio apenas com os ponteiros dos segundos.

int relogio;
int intervalo=1000;

float angulo = 270;
void setup() {
relogio=millis();
size(500, 500);
}
void draw() {
if (millis()>relogio+intervalo)
{
    relogio=millis();
    background(255);
    cronometro();
     angulo += 6;
}
}

void polar(float angulo, float raio)
{
float x = raio * (cos(radians(angulo)));
float y = raio * (sin(radians(angulo)));              //Decomposição dos vetores x e y para descoberta do valor do ponto desejado.
line(250,250, x+250,y+250);
}
void cronometro()
{
//função repsonsável por desenhar o cronometro
     ellipse(250,250,200,200);
     polar(angulo, 80);
}

quinta-feira, 10 de abril de 2014

Harmonografo

(Harmonia + grafia) Instrumento para combinar e registrar mecanicamente duas ou mais vibrações em uma só curva. Geralmente, são máquinas que simulam dois braços em forma de pêndulo e, com uma caneta ou lápis na ponta de cada braço, realizam movimentos circulares em superfícies, de acordo com o balanço de cada pêndulo em atuação com a gravidade (a frequência, a fase e a amplitude).

A criação dessas máquinas, que começaram a aparecer em meados do século 19 e chegou em popularidade na década de 1890, não podem ser conclusivamente atribuídas a uma única pessoa, embora acredita- se que Hugh Blackburn, professor de matemática na Universidade de Glasgow, possa ter sido o inventor oficial.

Um tipo de harmonógrafo também bem conhecido é o pantógrafo, que usam motores elétricos em vez de pêndulos para mover uma caneta para criar desenhos fantasticamente detalhados e belas linhas. A principal diferença entre este e o harmonógrafo tradicional, além dos motores, é que o pantógrafo possui braços em formato de tesouras que podem ter suas posições alteradas para formarem desenhos diferentes de acordo com a velocidade atribuída a eles.

Há também quem utilize tipos de harmonógrafos como brinquedos. É o caso do espirógrafo, um brinquedo muito famoso que consiste em um conjunto de engrenagens, anéis e retas de plástico com dentes e buracos em seu interior, que, para usá-los, se encaixam um dentro do outro e, em cima de uma folha de papel, com a ajuda de um lápis introduzido nos buracos vazados das peças e arrastado pelo papel, fazem as peças se moverem em movimentos uniformes, desenhando no papel diversas formas.

Nosso Hamonografo é baseado em funções trigonométricas seno e cosseno e variações de ângulo e amplitude.

O eixo X é baseado na formula = L/2 + cos(angulo1)*(a - i), onde L é a largura da tela, a é a amplitude inicial, e i é um incremento que se modifica em tempo de execução. Em tempo de execução as variáveis angulo1 e i são modificadas fazendo assim uma elipse com amplitude menor e com rotação diferente.

O eixo Y é baseado na formula = L/2 + seno(angulo1)*(a + i), onde L é a largura da tela, a é a amplitude inicial, e i é um incremento que se modifica em tempo de execução. Em tempo de execução as variáveis angulo1 e i são modificadas fazendo assim uma elipse com amplitude maior e com rotação diferente.

Utilizando x = 350 + cos(angulo1)*(200-i), onde angulo1 e i são iniciados em 0(zero),
Y = 350 + sen(angulo2)*(200+i), onde angulo2 é inciado em 60 e o i em 0 e com ajuda de algumas variáveis de controle para realizar o controle dos incrementos nós obtivemos a seguinte imagem:

No processing utilizamos a função descrita abaixo:

int relogio;        //Variável para fazer o timer
int intervalo=100; //intervalo em millisegundos

//Variáveis para criação do Harmonografo
int anguloHorizontal = 0;    //angulo inicial passado para posição x
int anguloVertical = 60;     //angulo inicial passado para posição y
float incHorizontal = 3;    //valor que incrementa o angulo dentro do método Desenho()
float incVertical = 3;      //valor que incrementa o angulo dentro do método Desenho()
float amplitude = 200;      //valor que será multiplicado ao resultado do coseno ou seno para a amplitude do desenho
float variacaoAmplitude = 6; //Valor que é utilizado para incrementar e decrementar a amplitude. Assim gerando a dinamica do desenho

//dimensoes da tela
int largura = 700;
int altura = 700;

//Angulos

float cos;
float sen;
float tan;

//Controle
boolean controle; //variável de controle para modificação de parametros

void desenho()
{

fill(cos*(100-variacaoAmplitude),sen*200,tan*(150+variacaoAmplitude));
ellipse(350+cos*(amplitude - variacaoAmplitude ) , 350+-sen*(amplitude +   variacaoAmplitude),10,10);
anguloHorizontal += incHorizontal;
anguloVertical += incVertical;
}

void draw()
{
cos = cos(radians(anguloVertical));
sen = sin(radians(anguloHorizontal));
tan = tan(radians(anguloHorizontal));
if (millis()>relogio+intervalo)
{
    relogio=millis();

    if(!controle)
    {
     variacaoAmplitude++;
    }
    else
    {
     variacaoAmplitude--;
    }

    if(variacaoAmplitude > 120)
    {
      controle = !controle;
    }
    else if(variacaoAmplitude < -120)
    {
     controle = !controle;
     anguloVertical = - anguloVertical;
     anguloHorizontal = - anguloHorizontal;
    }
}