Trabalho II - Vídeo sobre o resultado do primeiro trabalho.

Considerando o resultado gerado no Trabalho 1, elabore uma animação que apresente o conceito matemático considerado e demonstre sua relação com o respectivo código desenvolvido

Aqui está o resultado obtido:

Clique para assistir no vimeo: Trabalho 2 
Para Download: Download

Atividade 26

- Crie um histograma composto com os canais RGB de uma imagem

código:

primeiramente é criado um vetor para guardar os tons, uma variável pra imagem, duas variáveis para contabilizar o maior valor e tom mais frequente.

int [] tons = new int[256];
PImage img;

int maiorValor = 0;
int tomfrequente = 0;

dentro do setup(), estabelece-se o tamanho da tela, duas variáveis para a posição atual do pixel e uma para verificar a cor que eu quero no pixel atual

e guardar dentro do vetor.

void setup(){
  size(640,680);
  int pos, t;
  img = loadImage("oberyn.jpg");
  for (int x=0; x<640; x++){
    for (int y=0; y<480; y++){
      pos = y*640+x;
      t = (int)green(img.pixels[pos]);
      tons[t] = tons[t]+1;
    }
  }

na função drawGraphics são criadas algumas variáveis, de altura e largura das barras do histograma

e é criado uma condicional, que multiplica o tamanho da imagem com a posição ton no vetor e divide pelo maior valor, assim é criado um retangulo com a posição

no histograma.

void drawGraphics()
{

  int wBar = 2;
  int hBar = 0;
  
  int x = 0;
  int y = 0;
  
  for(int i = 0 ; i <256 ; i++)
  {  
    fill(10,55,100);
      hBar = (640 * tons[i])/maiorValor; 
      rect(x,height-hBar,wBar,hBar);
      x+=2;
      
  }

a função tomfrequente serve para contabilizar o tom que parece mais vezes na imagem, usa-se uma condicional que compara o valor atual do histograma e o seguinte.

int tomFrequente(int histograma[])
{
     int pos = 0;
     int maior = 0 ;
     
     for(int i = 0; i < 256; i++)
     {
        if(histograma[i] > maior)
        {
          maior = histograma[i];
          pos = i;
        }
     }
     this.maiorValor = maior;
     return pos;
}

Resultado:

Imagem Utilizada

Tons de Azul

Tons de Verde

Tons de Vermelho

Atividade 25

- Calcule a média e o desvio padrão da população de uma execução completa do jogo da vida simplificado

código:

a explicação do código aqui é basicamente a mesma para o jogo da vida das tarefas anteriores

a única coisa que muda é que agora é preciso incluir o desvio padrão dentro da função mostraMundo() uma variável recebe o desvio, que inicialmente é 0.

depois é criado uma condicional, e uma nova variável que recebe a potência do valor de i - o valor do contador ao quadrado. então esse valor é incrementado ao valor do desvio.

  cont = cont/32;
  float desvio = 0;
  for(int i = 1; i < 32; i++)
  {
    float p = pow(i - cont, 2);
    desvio+= p;
  }
  desvio = desvio / 32;
  println("Media: " + cont*32);
  println("Desvio padrão: " + sqrt(desvio));
}

Resultado:

Atividade 24

- Demonstre, graficamente, a relação existente entre entre a largura e altura de um retângulo para o melhor aproveitamento de seu espaço. Para tanto, proceda a realização das seguintes etapas:
1. Crie a função int calculaPerimetro(int Largura, int Altura);
2. Crie a função int calculaArea(int Largura, int Altura);
3. Crie uma aplicação inicial que execute o código a seguir:
for (int largura = 0; largura <= 10; largura++) {
println("Largura: " + largura);
int altura = 10 - largura;
println("Altura: " + altura);
int perimetro = calculaPerimetro(largura, altura);
println("Perimetro: " + perimetro);
int area = calculaArea(largura, altura);
println("Area: " + area);
println("");
}
4. Avalie o conjunto de resultados obtidos;
5. Analise as relações existentes entre largura e altura a fim de se obter o melhor aproveitamento do espaço deum retângulo. Para tanto, estabeleça um paralelo com a construção civil, e avalie o possível custo de construção do perímetro compreendido pelas paredes necessárias e a a área coberta correspondente;
6. Realize a demonstração gráfica de suas conclusões, através da criação de uma aplicação específica que faça uso de um ou mais dos diferentes tipos de gráficos estatísticos trabalhados e outras informações visuais julgadas necessárias.

código:

primeiramente cria-se duas variáveis para guardar a altura e a largura.

int altura;
int largura;

dentro do setup()

estabelece-se o tamanho da tela e a criação começa, primeiro com o fundo do gráfico

linhas horizontais, linhas verticais e a quantidade de dados.

void setup(){
 size(760,500);
  rect(50, 50, 660, 400);
  for(int i = 0; i < 24; i++)//linhas horizontais
  {
    stroke(200);
    line(50, 66 + (i * 16), 710,  66 + (i * 16));
  }
  for(int i = 0; i <= 25; i++)//informação de quantidade
  {
    fill(0);
    text(25 - i, 25, 50 + (i * 16) + 5);
  }
  for(int i = 0; i <= 10; i++)//linhas horizontais
  {
    stroke(0);
    noFill();
    line(110 + (60 * i), 50, 110 + (60 * i), 450);
  }

depois são criadas variáveis para cada dado, altura, perímetro e área.

são criados um retangulo para cada uma, já que o gráfico optado foi de barras.

  for(int largura = 0; largura <= 10; largura++) {
  println("Largura: " + largura);
  int altura = 10-largura;
  println("Altura: " + altura);
  int perimetro = calculaPerimetro(largura,altura);
  println("Perimetro: " + perimetro);
  int area = calculaArea(largura,altura);
  println("Area: " + area);
  println("");
  //noStroke();
  fill(200,0,0); //largura
  rect(50,450 - (400*largura)/25, 20, (400*largura)/25);
  fill(0, 200, 0);//altura
  rect(70, 450 - (400 * altura)/25, 20, (400 * altura)/25);
  fill(0, 0, 200);//area
  rect(90, 450 - (400 * area)/25, 20, (400 * area)/25);
  translate(60,0);  
 }

estabelece-se os textos com os dados 

  fill(0);
  textSize(32);
  translate(-660,0);
  text("Largura x Altura x Area", 200, 35);
  textSize(24);
  text("largura", 150, 485);
  text("altura", 350, 485);
  text("area", 550, 485);
  fill(200, 0, 0);
  rect(250, 465, 25, 25);
  fill(0, 200, 0);
  rect(440, 465, 25, 25);
  fill(0, 0, 200);
  rect(620, 465, 25, 25);
  //stroke(1);
  //strokeWeight(1);
  //NumAndGrid();
 }

são criadas funções para calcular o perímetro e a área em cada condição.

int calculaPerimetro(int Largura, int Altura){
  return 2*Largura + 2*Altura;
}

int calculaArea(int Largura, int Altura){
  return Largura*Altura;
}

Resultado:

Atividade 23

- expor os resultados em seu blog de uma aplicação no jogo da
vida simplificado que apresente a cada geração um gráfico de
pizza com espaços do mundo ocupados e livres. Depois mostre
um gráfico de barras com os nascimentos e mortes de cada
geração

códigos:

primeiro estabelece-se a variável para guardar o número de gerações

e dois vetores para guardar os dois mundos.

int numeroGeracao = 1;
int[] mundoAtual = new int[34];
int[] mundoNovo = new int[34];

dentro do setup()

é colocado o frameRate que a animação irá acontecer, o tamanho da tela, a cor do background

e uma condicional que faz com que o vetor mundoAtual receba 1 ou 2 como valor.

void setup()
{
  frameRate(1);
  size(800, 400);
  background(0);
  for(int i = 1; i < 32; i++)
  {
    mundoAtual[i] = (int)random(2);
    //println(mundoAtual[i]);
  }
  
}

dentro do draw()

uma variável para armazenar o número de células

a função mostraMundo() é chamada.

uma condicional que estabelece que o numero de celulas é igual a função cruzaCelulas recebendo o contador i como parâmetro.

se o número de celulas for 2 uma nova geração é criada, se for 1, a geração morre.

usa-se a função Array

copy para copiar o vetor e incrementa-se o número de gerações.

void draw()
{
  int numeroCelulas = 0;
  mostraMundo();
  for(int i = 1; i < 32; i++)
  {
    numeroCelulas = cruzaCelulas(i);
    if(numeroCelulas == 2)
      mundoNovo[i] = 1;
    else
      mundoNovo[i] = 0;
  }
  arrayCopy(mundoNovo, mundoAtual, 34);
  numeroGeracao++;  
}

função mostraMundo()

nessa função tem uma condicional para checar se a geração está viva ou morta.

e cria-se uma variável vivos para desenhar na tela o gráfico de pizza.

void mostraMundo()
{
  int cont = 0;
  for(int i = 1; i < 32; i++)
  {
    if
    (mundoAtual[i] == 1)
      cont++;
      //ellipse(i * 20, numeroGeracao * 30, 20, 20);
  }
  float vivos = (float)cont/32 * TWO_PI;
  println(cont);
  //ellipse(numeroGeracao * 30, height-y, 20, 20);
  fill(172, 25, 22);//ESPAÇOS OCUPADOS
  arc(width/2, height/2, width/2, width/2, 0, vivos);
  fill(10, 175, 10);//ESPAÇOS LIVRES 
  arc(width/2, height/2, width/2, width/2, vivos, TWO_PI);
}

a função CruzaCelulas() faz a checagem no mundoAtual pra ver se a geração irá viver ou morrer.

int cruzaCelulas(int posicao)
{
  int numeroCelulas = mundoAtual[posicao - 1] + mundoAtual[posicao] + mundoAtual[posicao + 1];
  return numeroCelulas;
}

para o gráfico de barras será utilizada a mesma lógica, só muda que na função de desenhar o gráfico na tela usa-se retangulos no lugar de arcos, e muda-se o posicionamento deles para ficarem corretos na tela.

void mostraMundo()
{
  int cont = 0;
  for(int i = 1; i < 32; i++)
  {
    if
    (mundoAtual[i] == 1)
      cont++;
      //ellipse(i * 20, numeroGeracao * 30, 20, 20);
  }
  float vivos = (float)cont/32 * height;
  float mortos = (float)(32-cont)/32 * height;
  println(cont);
  fill(0,200,0);
  rect(numeroGeracao*30, height - vivos, 10, vivos);
  fill(200, 0, 0);
  rect(numeroGeracao*30 + 11, height - mortos, 10, mortos);
}

Resultado:

jogo da vida - gráfico de pizza

jogo da vida - gráfico de barra

Atividade 22

- incluir um gráfico de linha que apresente
a evolução da quantidade de células a cada geração

código:

primeiro estabelece-se a variável para guardar o número de gerações

e dois vetores para guardar os dois mundos.

int numeroGeracao = 1;
int[] mundoAtual = new int[34];
int[] mundoNovo = new int[34];

dentro do setup()

é colocado o frameRate que a animação irá acontecer, o tamanho da tela, a cor do background

e uma condicional que faz com que o vetor mundoAtual receba 1 ou 2 como valor.

void setup()
{
  frameRate(1);
  size(800, 400);
  background(255);
  for(int i = 1; i < 32; i++)
  {
    mundoAtual[i] = (int)random(2);
    //println(mundoAtual[i]);
  }
  
}

dentro do draw()

uma variável para armazenar o número de células

a função mostraMundo() é chamada.

uma condicional que estabelece que o numero de celulas é igual a função cruzaCelulas recebendo o contador i como parâmetro.

se o número de celulas for 2 uma nova geração é criada, se for 1, a geração morre.

usa-se a função Array

copy para copiar o vetor e incrementa-se o número de gerações.

void draw()
{
  int numeroCelulas = 0;
  mostraMundo();
  for(int i = 1; i < 32; i++)
  {
    numeroCelulas = cruzaCelulas(i);
    if(numeroCelulas == 2)
      mundoNovo[i] = 1;
    else
      mundoNovo[i] = 0;
  }
  arrayCopy(mundoNovo, mundoAtual, 34);
  numeroGeracao++;  
}

função mostraMundo()

nessa função tem uma condicional para checar se a geração está viva ou morta.

e cria-se uma variável vivos e desenha-se na tela o gráfico de linhas com as gerações vivas e mortas.

void mostraMundo()
{
  int cont = 0;
  for(int i = 1; i < 32; i++)
  {
    if
    (mundoAtual[i] == 1)
      cont++;
      //ellipse(i * 20, numeroGeracao * 30, 20, 20);
  }
  float vivos = (float)cont/32 * height;
  float mortos = (float)(32-cont)/32 * height;
  println(cont);
  strokeWeight(5);
  stroke(0,255,0);
  line(numeroGeracao*30 , height - vivos, numeroGeracao*30, height);
  stroke(255,255,0);
  line(numeroGeracao*30 + 11, height - mortos, numeroGeracao*30 + 11, height);
}

a função CruzaCelulas() faz a checagem no mundoAtual pra ver se a geração irá viver ou morrer.

int cruzaCelulas(int posicao)
{
  int numeroCelulas = mundoAtual[posicao - 1] + mundoAtual[posicao] + mundoAtual[posicao + 1];
  return numeroCelulas;
}

Resultado:

Atividade 21

- discutir a relação entre o processo de chroma key
e a teoria dos conjuntos

Imagem meramente ilustrativa

Chroma key é uma técnica de efeito visual que consiste em colocar uma imagem sobre uma outra através do anulamento de uma cor padrão, como por exemplo o verde ou o azul.

É uma técnica de processamento de imagens cujo objetivo é eliminar o fundo de uma imagem para isolar os personagens ou objetos de interesse que posteriormente são combinados com uma outra imagem de fundo.

Ela se relaciona as teorias do conjunto, de forma que se dividirmo uma imagem em pixels branco e o fundo dela me pixels pretos, é como se existissem dois conjuntos... então tudo que for branco será considerado pertecente ao conjuto "pessoa" e tudo que for preto será considerado pertecente ao conjunto "fundo".

Trabalhar a imagem em conjuntos facilita para trabalhar os elementos nela existente de formas separadas. Em uma imagem pode existir diversos tipos de conjuntos, por exemplo: um conjunto com as pessoas, um conjunto com os objetos, um conjunto com as árvores, um conjunto com os prédios etc. Assim na hora da edição através do Chroma Key, é possível fazer a substituição do conjunto que seja considerado necessário.