segunda-feira, 30 de novembro de 2015

MAMI Trabalho

A obra escolhida foi :




                                                        Jesús Rafael Soto , Répétition optique Nº 2 , 1951

                1)Estudo de padrão


       
                                   


              Após o reconhecimento do padrão foi necessário reconhecer as formas envolvidas e 
               suas relações para passar pro programa.








                Depois criar uma disposição igual à obra.





               2)Criação do código


                  a)Criar função do padrão.

                  b)Criar um método de repetição para preenchimento de qualquer tamanho de tela.




float lar = 30;            //largura desejada
float alt = lar * 2;      //altura em relação com largura
float x = 100;            //posição x do primeiro padrão a ser criado
float y = 100;            //posição y do primeiro padrão a ser criado
float xAt = x;
float yAt = y;
int cont = 0;
int cont2 = 1;
void setup()
{
  size(800,600);
  noStroke();
}
void padrao(float l , float h,float x ,float y)             //padrão
{
  fill(255);
  quad(x , y , x+l , y , x+l , y+h , x , y+h);
  fill(255,195,85);
  quad(x , y , x+ l/2  ,y , x+l/2 , y + h/2 , x , y+h/2);
  fill(44,37,39);
  quad(x+l/2 , y + h/2 , x+l , y+h/2 , x+l , y+h , x+l/2 , y+h);
  triangle(x , y , x + l/4 , y , x , y + h/2);
  triangle(x + l/4 , y + h/2 , x + l/2 , y + h/2 , x + l/2 , y + h);
  fill(255);
  triangle(x + 3*l/4 , y+h/2, x+l , y+h/2 , x + l , y + h);
}

void draw()
{
  
  if((xAt > -lar) && (cont == 0))           //criação da linha para a esquerda
  {
  padrao(lar,alt,xAt,yAt);
  xAt = xAt - lar;
  }
  else
  {
    if(cont == 0)
    {
    cont = 1;
    xAt = x;
    }
  }
  if((xAt < width) && (cont == 1))   //criação da linha para a direita
  {
    padrao(lar,alt,xAt,yAt);
    xAt = xAt + lar;
  }
  else
  {
    if (cont == 1)      //alteração de colunas
    {
      cont = 0;
      yAt = yAt + cont2 * alt;
      xAt = x;
    }
    else
    {
      if(yAt > height)  //inversão da criação de colunas
      {
        yAt = y;
        xAt = x;
        yAt = yAt -  alt;
        cont = 0;
        cont2 = -cont2;
        
      }
    }
  }
}
               
          

         Resultado:

                          



                 3)Aplicação

                 Estudo de linhas para criação de aplicações:


                     







                 3.1)  Retirando elementos conseguiu-se os seguintes resultados:

                 
                                 variação 1
                   



                              variação 2



  fill(255);
  triangle(x , y , x + l/3 , y + h/2 , x , y + h/2);
  triangle(x + l/3 , y , x + 2 * l/3 , y + h/2 , x + l/3 , y + h/2);
  fill(0); 
  triangle(x + l/3 , y+h/2, x+2*l/3 , y+h/2 , x + 2*l/3 , y + h);
  triangle(x + 2*l/3,y + h/2, x+l , y + h/2,x + l, y+h);

                                 


                  3.2)Utilização de cores randômicas criando texturas:








  quad(x , y , x+l , y , x+l , y+h , x , y+h);
  fill(random(0,255));
  quad(x , y , x+ l/2  ,y , x+l/2 , y + h/2 , x , y+h/2);
  fill(random(0,255));
  quad(x+l/2 , y + h/2 , x+l , y+h/2 , x+l , y+h , x+l/2 , y+h);
  triangle(x , y , x + l/4 , y , x , y + h/2);
  triangle(x + l/4 , y + h/2 , x + l/2 , y + h/2 , x + l/2 , y + h);
  fill(random(0,255));
  triangle(x + 3*l/4 , y+h/2, x+l , y+h/2 , x + l , y + h);



                 3.3) Inspiração em obra física de Jesús Soto:







float lar = 10;
float alt = lar * 20;
float x = 100;
float y = 100;
float xAt = x;
float yAt = y;
int cont = 0;
int cont2 = 1;
void setup()
{
  size(800,600);
  noStroke();
}
void padrao(float l , float h,float x ,float y)
{
  fill(0);
  quad(x , y , x+l , y , x+l , y+h , x , y+h);
  quad(x , y , x+ l/2  ,y , x+l/2 , y + h/2 , x , y+h/2);
  quad(x+l/2 , y + h/2 , x+l , y+h/2 , x+l , y+h , x+l/2 , y+h);
  fill(255);
  triangle(x , y , x + l/6 , y , x , y + h/2);
  triangle(x + l/6 , y + h/2 , x + l/2 , y + h/2 , x + l/2 , y + h);
  triangle(x + 3*l/4 , y+h/2, x+l , y+h/2 , x + l , y + h);
}



Referências :


















                 











segunda-feira, 23 de novembro de 2015

MAMI Atividade 11

Função é um objeto de trabalho valioso nas mãos de bons programadores.Pode ser muitas vezes não ser necessária para a funcionalidade do código,mas ele fica desorganizado e extremamente mais extenso.O programador que usa função economiza tempo de trabalho além de deixar seu código mais didático.Facilita a alteração, caso seja preciso, e a percepção de objetos dentro do programa.

   Um excelente exemplo para isso é o jogo Light-Bot que o jogador deve atribuir ao protagonista determinadas tarefas.Quando elas chegam a ficar repetitivas o jogo obriga o usuário a utilizar função e o que no começo seria estranho devido a saída da zona de conforto passa a ser bem mais prático e rápido.

Link do jogo:
http://www.clickjogos.com.br/Jogos-online/Puzzle/Light-Bot/


MAMI Atividade 10

   O pong se resumiu a união de todos os ensinamentos até agora com a adição de movimentação pelo teclado. A utilização de funções foi fundamental para resumir o código e não torna-lo tão repetitivo.

- Primeiro devia-se criar os elementos que seriam um círculo e dois retângulos.

- Estabelecer os pontos de colisão.

- Criar as regras de colisões e os movimentos dos elementos e o que cada causaria.

Obs: use as teclas UP e DOWN (para o retângulo esquerdo)  5 e 2 ( para o retângulo direito)

Código:

float ex = 160;
float ey = 120;
int xRec1 = 280;
int yRec1 = 80;
int xRec2 = 20;
int yRec2 = 80;
float vx = -0.7;
float vy = -0.5;
void setup()
{
  size(320,240);
  background(0);
  noStroke();


}
boolean Colisaoxa(float xp ,int x1 ,int x2)
{
  if (( xp >= x1) && (xp <= x2))
  {

    println("Dentroxa");
    return true;
  }
  else
  {
    println("Foraxa");
     return false;
  }
}
boolean Colisaoya(float yp ,int y1 ,int y2)
{
  if (( yp >= y1) && (yp <= y2))
  {

    println("Dentroya");
    return true;
  }
  else
  {
    println("Foraya");
     return false;
  }
}
boolean Colisaoxb(float xp ,int x1 ,int x2)
{
  if (( xp >= x1) && (xp <= x2))
  {

    println("Dentroxb");
    return true;
  }
  else
  {
    println("Foraxb");
     return false;
  }
}
boolean Colisaoyb(float yp ,int y1 ,int y2)
{
  if (( yp >= y1) && (yp <= y2))
  {

    println("Dentroyb");
    return true;
  }
  else
  {
    println("Forayb");
    return false;
  }
}

void draw()
{

  background(0);
  ellipse( ex , ey ,20,20);
                                                               
  rect(xRec1 , yRec1 , 20, 80);
  rect(xRec2 , yRec2 , 20 , 80);
 if( (Colisaoxa(ex ,  xRec1 - 10  ,xRec1 + 10)) && (Colisaoya(ey , yRec1  , yRec1 + 80)))
 {
 println("retorna");
 vx = -vx;


 }
  if ((Colisaoxb(ex , xRec2 +10 ,xRec2 + 30)) && (Colisaoyb(ey , yRec2 , yRec2 + 80)))
  {
   println("retorna");
   vx = -vx;
   vx = vx + 0.5 * vx;

 }
 if ((ey <= 10) || (ey >= (height - 10)))
{
 println("retorna");
 vy = -vy;
 vy = vy + 0.5 * vy;
}

ey = ey + vy;
ex = ex + vx;

}

void keyPressed()
{
   if((keyCode == UP) && (yRec2 >= 10))
  {
    yRec2 = yRec2 - 5;
 
  }
  if((keyCode == DOWN) && (yRec2 <= 150))
  {
    yRec2 = yRec2 + 5;
 
  }

  if((key == '5') && (yRec1 >= 10))
  {
    yRec1 = yRec1 - 5;
 
  }
  if((key == '2') && (yRec1 <= 150))
  {
    yRec1 = yRec1 + 5;
 
  }
}




MAMI Atividade 9

Primeiro precisa-se limitar até onde a bola chegará relacionando com o raio que está em constante mudança.Nesse limite invertemos as velocidades para ele ricochetear e adicionamos o aumento desejado.

Foi criado um limite para a alteração do raio da circunferência.

Código:

float xBola = 21;
float yBola = 300;
float Vx = 5;
float Vy = 5;
float R = 20;
float T = 0.1;
void setup()
{
  size(800,600);
  noStroke();
}

void draw()
{
  background(125);
  R = R + T;
  if ((xBola >= width - R) || (xBola <= R))
 {
   Vx = Vx + 0.01 * Vx;
   Vy = Vy + 0.01 * Vy;
   Vx = Vx * -1;
 }
 if ((yBola >= height - R) || (yBola <= R))
 {
   Vx = Vx + 0.01 * Vx;
   Vy = Vy + 0.01 * Vy;
   Vy = Vy * -1;
 }
 
  fill(0);
  ellipse(xBola,yBola,2*R,2*R);
 if((R <= 10) || (R >= 40))
 {
  T = -T;
 }


xBola = xBola + Vx;
yBola = yBola + Vy;
println(Vx,Vy);
}

Resultado:



MAMI Atividade 8

Para resolvermos o problema precisamos de usar o teorema de Pitágoras para saber a distância usamos então como demostrado abaixo:





Depois é só relacionar esses valores ao x,y do mouse com o x,y da circunferência.


Código:

float R1 = random(50,300);
float R2 = random(50,300);
float X1 = random(10,200);
float X2 = random(410,600);
float Y1 = random(100,500);
float Y2 = random(100,500);
void setup()
{
  size(800,600);
  noStroke();
}
void draw()
{
  if ( (mouseX - X1)*(mouseX - X1) + (mouseY - Y1)*(mouseY - Y1) <= (R1 * R1))
 {
  fill(75); 
 } 
 else
 {
   fill(0);
 }
  ellipse(X1,Y1,2*R1,2*R1);
  if ( (mouseX - X2)*(mouseX - X2) + (mouseY - Y2)*(mouseY - Y2) <= (R2 * R2))
 {
  fill(75); 
 } 
 else
 {
   fill(0);
 }
  ellipse(X2,Y2,2*R2,2*R2);
  println(mouseX,mouseY);
}

Resultado:





MAMI Atividade 7

Escolhi o meu ponto de referencia como mostra na figura a sequir:






Então a partir dele foram marcadas as formas necessárias :

- 2 retângulos maiores

- 2 quadrados módulo x módulo

- 2 segmentos de circunferência

- 2 círculos menores

- 2 retângulos auxiliadores para ao se agregarem aos círculos criarem uma forma que deixasse visível só o necessário.

Próximo passo era deixar o "A" exatamente no meio tomando em relação o ponto de referência:






 Código: 


int H = 300;//altura//
int Soma = 5;//variação de tamanho//
float mod;//módulo//
float x ;
float y ;
void setup()
{
  background(255);
  size(800,600);
  noStroke();
 
  }

void draw()
{
  background(255);
  mod = H/7;
  x = width / 2 - 1.5 * mod;//posição central em relação ao ponto de referencia//
  y = height / 2 - 3 * mod;//posição central em relação ao ponto de referencia//
  fill(0);
  quad(x , y , x+ mod , y , x +  mod , y + 7 * mod , x , y + 7 * mod);//retangulo maior esquerdo//
  quad(x + 2 * mod, y , x+ 3 * mod , y , x + 3 * mod , y + 7 * mod , x + 2 * mod , y + 7 * mod);//retangulo maior direito//
  quad(x + mod - 1 , y + 3.5* mod, x + 2 * mod + 1 , y + 3.5* mod , x + 2 * mod + 1 , y + 4.5 * mod , x +  mod - 1, y + 4.5 * mod);//quadrado de baixo//
  quad( x + mod - 1, y - mod, x + 2 * mod + 1 , y - mod , x + 2 * mod + 1 , y + 0.25 * mod , x + mod - 1 , y + 0.25 * mod);//quadrado de cima//
  fill(255);
  ellipse(x + 1.125 * mod , y + 0.125 * mod , 0.25 * mod , 0.25 * mod);//circulo pequeno esquerdo//
  ellipse(x + 1.875 * mod , y + 0.125 * mod , 0.25 * mod , 0.25 * mod);//circulo pequeno direito//
  fill(0);
  arc(x + 2 * mod , y , 2 * mod , 2 * mod ,PI * 3/2, PI * 2 );//arco direito//
  arc(x +  mod , y , 2 * mod , 2 * mod , PI , PI * 3/2  );//arco esquerdo//
  fill(255);
  quad(x + 1.125 * mod , y , x + 1.875 * mod , y , x + 1.875 * mod , y + mod , x + 1.125 * mod , y + mod);//retangulo auxiliar 1//
  quad(x + mod , y + 0.125 * mod , x + 2 * mod , y + 0.125 * mod , x + 2 * mod , y + mod , x + mod , y + mod);//retângulo auxiliar 2//
  if ((H > 500) || ( H < 100))
  {
    Soma = Soma * -1;
  }
  
  H = H + Soma;
    
}

Resultado:





 
 

domingo, 15 de novembro de 2015

MAMI Atividade 6

Regras para formação da bandeira:

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).


Código:

float largura = 300;
float posx = 10;
float posy = 10;
void setup(){
  size(800,600);
  noStroke();
  mostraBandeira(posx , posy , largura);
}
    
    void mostraBandeira(float x,float y,float l){
     float m  =  l / 20;  //módulo onde ele se relaciona com a largura oferecida//
     float a = 0.7 * l;  //Altura que seria 14 módulos em relação aos 20 da largura 14/20 = 0.7//
     fill(22,186,62);
     quad (x , y , x+l , y , x + l , y +a , x , y+a); 
     fill(255,255,31);
     quad(x + 1.7*m , a/2 + y , x + l/2 , y + 1.7 * m , x + l - 1.7 * m , a/2 + y , x + l/2 , y + a - 1.7*m);
     fill(22,81,184);
     ellipse(x + l/2 , y + a/2, 7 * m , 7 * m); // 7 porque é o diâmetro que o raio é 3.5//
   }



-A adição ou subtração do "1.7 * m" é o distanciamento do losango às bordas dos retângulo                  dependendo do ponto desejado a partir do ponto inicial x,y.
- Uso das metades da altura e da largura para posicionar os pontos do losango.




quarta-feira, 11 de novembro de 2015

MAMI Atividade 5

Levando em conta que o lançamento balístico pode ser dividido em dois vetores X(horizontal) e Y(vertical) e que eles correspondem a um MRU e MRUV criei as variáveis necessárias para cada movimento:

v: velocidade
x: horizontal
y: vertical
Ini: inicial
Atu: atual
Posi:posição
g: grade

Código:

float vx = 50;
float vIniY = -40 ;
float vAtuy ;
float a = 10;
float PosiInix = 40;
float PosiIniy = 560;
float PosiAtux;
float PosiAtuy;
float tempo = 0;
float g;

void setup(){
  frameRate(10);
  size(600,600);

}
void draw(){
background(255);
  for (g = 0; g<12; g++){
    stroke(125);
    line(g*50, 0, g*50, 600);
    line(0, g*50, 600, g*50);
  }
 PosiAtux = PosiInix + vx * tempo;
 PosiAtuy = PosiIniy + +vIniY * tempo + a * tempo * tempo / 2;
 fill(125);
 ellipse(PosiAtux,PosiAtuy,40,40);
tempo = tempo + 0.1;
textSize(15);
fill(0);
text("Posição atual : horizontal = " +  PosiAtux + "  vertical = " + (600 - PosiAtuy)  ,30,30);
text("tempo : " + tempo,30,55);

}
 

quinta-feira, 5 de novembro de 2015

MAMI Atividade 4

Alterar o mundo de acordo com uma harmonia cromática a sua
escolha e, informar na própria tela (comando text) em tempo
real, os valores de todas as variáveis envolvidas na simulação


Harmonia cromática escolhida:  

 1º cor : R:255 G:0 B:1 (cor da bola)
                                                    


 2º cor : R:255 G:96 B:0 (cor das linhas)
                                                   
 

 3º cor : R:253 G:146 B:2 (cor do background) 
                                                                   
  Código:

int tAtual = 0 ;
int vAtual = 20;
int dAtual;
void setup(){
  size(600,600);
  frameRate(1);
   background(253,146,2);
}

int MRU(int v, int t){
  int d;
  d = v*t;
  return(d);
}

void mostraGrade(){
  for (int i = 0 ;i < 12;i++){
    stroke (255,96,0);
    line(i*50,0,i*50,600);
  
}
}
void draw(){
  background(253,146,2);
  noStroke();
  fill(255,0,1);
  ellipse(dAtual,height/2,30,30);
  dAtual = MRU(vAtual,tAtual);
  println(tAtual,dAtual);
  tAtual++;
  mostraGrade();
  line(0,300,600,300);
  fill(0);
  textSize(20);
  text (" Posição " + dAtual + " pixels ", 15 , 40);
  text (" Velocidade " + vAtual + " p/s ", 15, 65);
  text (" Tempo " + (tAtual - 1) + " segundos " , 15 , 90);
}



terça-feira, 3 de novembro de 2015

MAMI Atividade 3

Quando observei o problema primeiramente procurei uma forma de encontrar o x e o y das circunferências tangentes a partir de que a distância entre os centros de todas elas eram dois raios ou uma diagonal.






    A partir disto fazendo um triângulo retângulo para descobrir o cateto 1(alteração no x) e o cateto 2(alteração no y) caso 1 a partir da diagonal e assumindo que é também um triângulo isósceles com angulação 45 45 90.

    Depois do cálculos descobri que cada cateto corresponde a : cateto = diagonal * raiz de dois dividido por 2.
    Assim dependendo de qual circulo se deseja criar deve-se adicionar ou diminuir esse valor tanto no x quanto do y.

Código:
void setup(){
size(300,300);


ellipse(150,150,90,90);
ellipse(150 - 90 *sqrt(2)/2,150 - 90 *sqrt(2)/2,90 ,90);
ellipse(150 + 90 *sqrt(2)/2,150 + 90 *sqrt(2)/2,90 ,90);
ellipse(150 - 90 *sqrt(2)/2,150 + 90 *sqrt(2)/2,90 ,90);
ellipse(150 + 90 *sqrt(2)/2,150 - 90 *sqrt(2)/2,90 ,90);
}



A Flor não ficou perfeita.*Provavelmente porque a alteração na vertical é diferente da horizontal.
Porém precisava de uma relação e não encontrei uma melhor para poder criar diferentes flores a partir desse ponto.(Peço ajuda caso tenha uma maneira correta )

Código final:
void setup(){
size(300,300);
frameRate(3);
}
void draw(){
float x = random(100,200);
float y = random(100,200);
float w = random(10,90);
background(255);
ellipse(x,y,w,w);
ellipse(x - w *sqrt(2)/2,y - w *sqrt(2)/2,w ,w);
ellipse(x + w *sqrt(2)/2,y + w *sqrt(2)/2,w ,w);
ellipse(x - w *sqrt(2)/2,y + w *sqrt(2)/2,w ,w);
ellipse(x + w *sqrt(2)/2,y - w *sqrt(2)/2,w ,w);
}