“The Beauty of Data Visualization” de David McCandless

"Dados são o novo petróleo." E os dados são uma espécie de recursos ubíquos que podemos moldar para fornecer inovações e novas percepções e está por todo o lado, e pode ser extraída muito facilmente. "

Informações nunca tiveram tanto valor. Principalmente informações sobre temas variados. Hoje, se você não está atualizado sobre tudo, você não é uma pessoa suficientemente "inteligente". Hoje se faz necessário ter compreensão, uma "opinião formada sobre tudo", e isso é no que a tecnologia vem apostando nos últimos anos. 

Meios de comunicação que utilizam de recursos visuais nunca foram tão procurados. Notebooks de ponta são as novas ferramentas para nos mantermos informados por ser um recurso mais visual; as televisões foram (quase) esquecidas, o que dirá dos rádios e jornais de papel.

Hoje, se uma informação não chega com atrativos, é descartada, é tratada como desinteressante, então nada mais compreensível que as novas tecnologias hoje se adequem a o que é bonito de se ver, que atraiam o olhar, e David McCandless nos mostra uma ferramenta muito importante para que essa ideia seja válida, os gráficos e infográficos.

Para entender um infográfico você não precisa ler um texto enorme sobre o assunto, você só precisa olhar para ele e entender o que significam os poucos dados que nos informam, como, por exemplo o gráfico do fim do vídeo, onde David pergunta ao público sobre o que tratava o gráfico que ele mostrou e recebeu diversas interpretações das pessoas. É isso o que a tecnologia hoje deseja: maior compreensão dada da melhor forma possível.

Jogo da Vida com Zoom

O exercício proposto foi achar um modo de dar um zoom no jogo da vida para melhor visualização dos comportamentos. Descobri que já existia uma função no processing que fazia isso automaticamente. A scale() onde pode-se passar por parametro a quantidade de vezes que pretende dar um zoom.

//A tela terá dimensão tam x tam
int tam = 100;
//Como o tipo PImage é armazenado em vetor, então...
int vtam = tam*tam;
//Imagem a ser exibida
PImage mundo = createImage(tam, tam, RGB);
//Imagem auxiliar para criar uma geração
PImage mundoTemp = createImage(tam, tam, RGB);

int geracao = 0;
int maiorPopulacao = 0;
int menorPopulacao = 0;

void setup() {
  size(800, 800);
  background(0);
  frameRate(5);
  criaMundo();
}

void draw() {
 
 
  scale(8);
  //Criando gerações
  evoluiMundo();
  //Exibindo
  image(mundo, 0, 0);
  geracao++;
  maiorPopulacao = maiorPopulacao(maiorPopulacao);
  menorPopulacao = menorPopulacao(menorPopulacao);
  println("Numero de células vivas " + contaCelulas() + " na geração " + geracao);
  println("Maior população: " + maiorPopulacao);
  println("Menor população: " + menorPopulacao);
}

//cria uma geração
void evoluiMundo() {
  /*A nova geração será guardada em mundoTemp, então
   é necessário copiar a geração atual para mundoTemp */
  for (int i=0; i<vtam; i++)
    mundoTemp.pixels[i] =  mundo.pixels[i];

  //Contador de vizinhos 
  int vizinhos;
  //Para cada célula aplicar as regras do jogo da vida
  for (int i=1; i<tam-1; i++)
    for (int j=1; j<tam-1; j++) {
      vizinhos = contaVizinhos(i, j); //Qtde de vizinhos de uma célula i,j     
      //Se a célula viva, ...
      if (mundo.pixels[pos(i, j)] == color (0, 255, 0)) {
        //Menor que 2 vizinhos ou maior que 3, morra
        if ((vizinhos < 2) ||(vizinhos > 3))
          mundoTemp.pixels[pos(i, j)] = color (0, 0, 0);
      }
      //Se morta, mas com 3 vizinhos, viva
      else if (vizinhos == 3)
        mundoTemp.pixels[pos(i, j)] = color (0, 255, 0);
    }

  //Depois de geração criada, atualizar o mundo, copiando de mundoTemp
  mundo.loadPixels();
  for (int i=0; i<vtam; i++)
    mundo.pixels[i] = mundoTemp.pixels[i];
  mundo.updatePixels();
}

//Conta quantos vizinhos a célula possui
int contaVizinhos(int i, int j) {
  int vizinhos=0;
  vizinhos = celula(i-1, j-1) + celula(i-1, j) + celula(i-1, j+1)
    +celula(i, j-1) + celula(i, j+1) + celula(i+1, j-1)
      +celula(i+1, j) + celula(i+1, j+1);
  return vizinhos;
}

//Se a célula for viva (cor 0,255,0 - verde), retorna 1, senão 0
int celula(int i, int j) {
  if (mundo.pixels[pos(i, j)] == color(0, 255, 0))
    return 1;
  return 0;
}

//Mapeia a posição da matriz em um vetor
int pos(int i, int j) {
  return j * tam + i;
}

//Conta células vivas
int contaCelulas()
{
  int c = 0;

  for (int i = 0; i < vtam; i++)
  {
    if (mundo.pixels[i] == color(0, 255, 0))
    {
      c++;
    }
  }
  return c;
}

//Verifica a maior populacao existente
int maiorPopulacao(int maior)
{
  if (contaCelulas() > maior)
  {
    maior = contaCelulas();
  }
  return maior;
}

//Verifica a menor populacao existente
int menorPopulacao(int menor)
{
  if (menor == 0)
  {
    menor = contaCelulas();
  }
  else if (contaCelulas() < menor)
  {
    menor = contaCelulas();
  }
  return menor;
}


//Cria um mundo aleatório em um quadrado central que vai de 1/3 a 2/3 da tela
void criaMundo() {

  for (int i=0; i<vtam; i++)
  {
    int x = int(random(tam/3, 2*tam/3));
    int y = int(random(tam/3, 2*tam/3));
    mundo.pixels[pos(x, y)] = color(0, 255, 0);
  }
}