Mostrando postagens com marcador Processing. Mostrar todas as postagens
Mostrando postagens com marcador Processing. Mostrar todas as postagens

sexta-feira, 5 de abril de 2013

Renda e IDH dos estados brasileiros e países sul-americanos

Resolvi juntar os dados dos países da América do Sul com os dados dos estados brasileiros. O resultado não foi inesperado, mas ainda assim a imagem ilustra muito bem como os estados brasileiros ocupam todo o espectro da renda e do desenvolvimento humano da América do Sul. Clique na imagem para ampliá-la.


O eixo vertical indica o IDH e o eixo horizontal indica a renda. As linhas cinzas indicam as médias para o continente.

Oito unidades federativas estão acima da renda média sul-americana: MT, PR, RS, ES, SC, RJ, SP, e DF. Além disso, 21 estão acima do IDH médio: todos menos PI, MA, AL, PB, CE, e PE.

As unidades federativas RJ, SP e DF estão acima da renda e do IDH de todos os países sul-americanos. Elas possuem mais de 57 milhões de habitantes, o que equivale aproximadamente à população do Chile e da Argentina somadas (são os dois países de melhor renda e IDH do continente).

Ainda mais interessante é o fato de que 6 estados têm IDH maior que o Chile (campeão sul-americano). Isso significa que quase 85 milhões de brasileiros vivem numa região com IDH superior ao IDH dos 17 milhões de chilenos.

No outro extremo, PI e MA são mais pobres que a Bolívia (em renda per capita), mas, ao menos, mantêm-se acima do IDH desse país.


<html>
<head>
<script src="processing-1.4.1.min.js"></script>
<script type="text/processing" data-processing-target="canvas">
  class Pais {
    int populacao, idh, renda, cor;

    Pais(int p, int i, int r, int c) {
      populacao=p;
      idh=i;
      renda=r;
      cor=c;
    }
  }

  HashMap paises=new HashMap();
  paises.put("Argentina", new Pais(40482000,797,17516,4));
  paises.put("Bolivia", new Pais(9863000,663,4789,1));
  paises.put("Brasil", new Pais(191241714,718,11769,0));
  paises.put("Chile", new Pais(16928873,805,17222,0));
  paises.put("Colombia", new Pais(45928970,710,10249,1));
  paises.put("Equador", new Pais(14573101,720,8492,1));
  paises.put("Guiana", new Pais(772298,633,7465,3));
  paises.put("Paraguai", new Pais(6831306,665,5413,3));
  paises.put("Peru", new Pais(29132013,725,10062,2));
  paises.put("Suriname", new Pais(472000,680,9475,3));
  paises.put("Uruguai", new Pais(3477780,783,15113,4));
  paises.put("Venezuela", new Pais(26814843,735,12568,2));

  int[] cores=new int[] {#98db11, #ff9900, #ffd42a, #ff0000, #5599ff};
  
  class Estado {
    int populacao, idh, renda, regiao;

    Estado(int p, int i, int r, int s) {
      populacao=p;
      idh=i;
      renda=r;
      regiao=s;
    }
  }

  HashMap estados=new HashMap();
  estados.put("AC", new Estado(707125,751,7041,0));
  estados.put("AL", new Estado(3093994,677,5164,1));
  estados.put("AP", new Estado(648553,780,8543,0));
  estados.put("AM", new Estado(3350773,780,11829,0));
  estados.put("BA", new Estado(13633969,742,6922,1));
  estados.put("CE", new Estado(8180087,723,5636,1));
  estados.put("DF", new Estado(2469489,874,37600,2));
  estados.put("ES", new Estado(3392775,802,15236,3));
  estados.put("GO", new Estado(5849105,800,9962,2));
  estados.put("MA", new Estado(6424340,683,4628,1));
  estados.put("MT", new Estado(3033991,796,12350,2));
  estados.put("MS", new Estado(2404256,802,10599,2));
  estados.put("MG", new Estado(19159260,800,11028,3));
  estados.put("PA", new Estado(7443904,755,6241,0));
  estados.put("PB", new Estado(3753633,718,5507,1));
  estados.put("PR", new Estado(10266737,820,13158,4));
  estados.put("PE", new Estado(8541250,718,6528,1));
  estados.put("PI", new Estado(3086448,703,4213,1));
  estados.put("RJ", new Estado(15180636,832,17695,3));
  estados.put("RN", new Estado(3121451,738,6754,1));
  estados.put("RS", new Estado(10576758,832,14310,4));
  estados.put("RO", new Estado(1535625,776,8391,0));
  estados.put("RR", new Estado(425398,750,9075,0));
  estados.put("SC", new Estado(6178603,840,15638,4));
  estados.put("SP", new Estado(39924091,833,19548,3));
  estados.put("SE", new Estado(2036277,742,7560,1));
  estados.put("TO", new Estado(1373551,756,7210,0));

  int[] regioes=new int[] {#98db11, #ff9900, #ffd42a, #ff0000, #5599ff};
  
  int W=2000;

  void setup() {
    size(W,W/2);
    background(255);
    noLoop();
  }

  void draw() {
    Iterator i = paises.entrySet().iterator();
    while (i.hasNext()) {
      Map.Entry me = (Map.Entry)i.next();
      String nome=me.getKey();
      Pais pais=me.getValue();
      float x=W*(pais.renda/40000);
      float y=W*(pais.idh/1000);
      float r=2+pais.populacao/1000000;
      fill(cores[pais.cor], 150);
      stroke(cores[pais.cor], 255);      
      ellipse(x, W-y, r, r);
      fill(0, 255);
      text(nome, x, W+4-y+r/2);
    }
    
    Iterator i2 = estados.entrySet().iterator();
    while (i2.hasNext()) {
      Map.Entry me = (Map.Entry)i2.next();
      String sigla=me.getKey();
      Estado estado=me.getValue();
      float x=W*(estado.renda/40000);
      float y=W*(estado.idh/1000);
      float r=2+estado.populacao/1000000;
      fill(regioes[estado.regiao], 100);
      stroke(regioes[estado.regiao], 255);      
      ellipse(x, W-y, r, r);
      fill(#000000, 255);
      text(sigla, x, W+4-y+r/2);
    }
    
    stroke(#AAAAAA, 255);
    float rendaMedia=(11962/40000)*W;
    line(rendaMedia, 0, rendaMedia, W);
    float idhMedio=W-(729/1000)*W;
    line (0, idhMedio, W, idhMedio);
    
    save("paises_estados.jpg");
  }
</script>
</head>
<body>
<canvas id="canvas">
</body>
</html>

quarta-feira, 6 de março de 2013

Renda e desenvolvimento da América do Sul

Aproveitei o código do artigo sobre a renda e o IDH dos estados brasileiros para fazer uma comparação dos países sul-americanos. Aproveitei para adicionar duas informações: a renda média e o IDH médio. Esses dados são representados, respectivamente, por uma linha vertical e uma linha horizontal. O tamanho de cada círculo representa o número de habitantes.

Clique na imagem para aumentá-la.

Eu ignorei as colônias (Malvinas e Guiana Francesa), porque não possuem informação sobre IDH.

Dado o seu tamanho, o Brasil só poderia mesmo estar nas redondezas das médias. Infelizmente, ele está um pouco abaixo das duas.

Argentina e Chile lideram com bastante folga, cada um desses países liderando num quesito, mas por pequena margem. Isso me remete ao fato de que, na nossa mídia, o Chile é frequentemente referido como um sucesso retumbante enquanto a Argentina é um fracasso trágico. Resulta que são muito parecidos. O Uruguai não está muito atrás no que concerne o IDH, mas a sua renda é sensivelmente menor.

Orbitam o Brasil a Venezuela, o Peru e a Colômbia. Esses países dificilmente são retratados em bons termos na nossa mídia, curiosamente. O Equador tem renda um tanto menor que a desse grupo, mas um IDH semelhante.

A Guiana e o Suriname destoam por terem IDHs pequenos para seus respectivos níveis de renda.

Eis o código:

<html>
<head>
<script src="processing-1.4.1.min.js"></script>
<script type="text/processing" data-processing-target="canvas">
  class Pais {
    int populacao, idh, renda, cor;

    Pais(int p, int i, int r, int c) {
      populacao=p;
      idh=i;
      renda=r;
      cor=c;
    }
  }

  HashMap paises=new HashMap();
  paises.put("Argentina", new Pais(40482000,797,17516,4));
  paises.put("Bolivia", new Pais(9863000,663,4789,1));
  paises.put("Brasil", new Pais(191241714,718,11769,0));
  paises.put("Chile", new Pais(16928873,805,17222,0));
  paises.put("Colombia", new Pais(45928970,710,10249,1));
  paises.put("Equador", new Pais(14573101,720,8492,1));
  paises.put("Guiana", new Pais(772298,633,7465,3));
  paises.put("Paraguai", new Pais(6831306,665,5413,3));
  paises.put("Peru", new Pais(29132013,725,10062,2));
  paises.put("Suriname", new Pais(472000,680,9475,3));
  paises.put("Uruguai", new Pais(3477780,783,15113,4));
  paises.put("Venezuela", new Pais(26814843,735,12568,2));

  int[] cores=new int[] {#98db11, #ff9900, #ffd42a, #ff0000, #5599ff};

  void setup() {
    size(1024,1024);
    background(255);
    noLoop();
  }

  void draw() {
    Iterator i = paises.entrySet().iterator();
    while (i.hasNext()) {
      Map.Entry me = (Map.Entry)i.next();
      String nome=me.getKey();
      Pais pais=me.getValue();
      float x=1024*(pais.renda/20000);
      float y=1024*(pais.idh/1000);
      float r=2+pais.populacao/1000000;
      fill(cores[pais.cor], 150);
      stroke(cores[pais.cor], 255);      
      ellipse(x, 1024-y, r, r);
      fill(0, 255);
      text(nome, x, 1032-y+r/2);
    }
    stroke(#AAAAAA, 255);
    float rendaMedia=(11962/20000)*1024;
    line(rendaMedia, 0, rendaMedia, 1024);
    float idhMedio=1024-(729/1000)*1024;
    line (0, idhMedio, 1024, idhMedio);
    
  }
</script>
</head>
<body>
<canvas id="canvas">
</body>
</html>

domingo, 3 de março de 2013

Renda e desenvolvimentos dos estados brasileiros

Depois de brincar com a linguagem Processing, resolvi avaliar a sua versão para Javascript. Parece que, atualmente, tudo está sendo refeito em Javascript. Esta é uma das instâncias em que isso tem sentido.

Busquei os dados dos estados brasileiros na Wikipédia. As informações que resolvi comparar são a renda, a população e o índice de desenvolvimento humano (IDH).

Foi surpreendentemente fácil; a tarefa mais laboriosa foi copiar os dados da Wikipédia para o programa.

  class Estado {
    int populacao, idh, renda, regiao;

    Estado(int p, int i, int r, int s) {
      populacao=p;
      idh=i;
      renda=r;
      regiao=s;
    }
  }

  HashMap estados=new HashMap();
  estados.put("AC", new Estado(707125,751,7041,0));
  estados.put("AL", new Estado(3093994,677,5164,1));
  estados.put("AP", new Estado(648553,780,8543,0));
  estados.put("AM", new Estado(3350773,780,11829,0));
  estados.put("BA", new Estado(13633969,742,6922,1));
  estados.put("CE", new Estado(8180087,723,5636,1));
  estados.put("DF", new Estado(2469489,874,37600,2));
  estados.put("ES", new Estado(3392775,802,15236,3));
  estados.put("GO", new Estado(5849105,800,9962,2));
  estados.put("MA", new Estado(6424340,683,4628,1));
  estados.put("MT", new Estado(3033991,796,12350,2));
  estados.put("MS", new Estado(2404256,802,10599,2));
  estados.put("MG", new Estado(19159260,800,11028,3));
  estados.put("PA", new Estado(7443904,755,6241,0));
  estados.put("PB", new Estado(3753633,718,5507,1));
  estados.put("PR", new Estado(10266737,820,13158,4));
  estados.put("PE", new Estado(8541250,718,6528,1));
  estados.put("PI", new Estado(3086448,703,4213,1));
  estados.put("RJ", new Estado(15180636,832,17695,3));
  estados.put("RN", new Estado(3121451,738,6754,1));
  estados.put("RS", new Estado(10576758,832,14310,4));
  estados.put("RO", new Estado(1535625,776,8391,0));
  estados.put("RR", new Estado(425398,750,9075,0));
  estados.put("SC", new Estado(6178603,840,15638,4));
  estados.put("SP", new Estado(39924091,833,19548,3));
  estados.put("SE", new Estado(2036277,742,7560,1));
  estados.put("TO", new Estado(1373551,756,7210,0));

  int[] regioes=new int[] {#98db11, #ff9900, #ffd42a, #ff0000, #5599ff};

  void setup() {
    size(512,512);
    background(255);
    noLoop();
  }

  void draw() {
    Iterator i = estados.entrySet().iterator();
    while (i.hasNext()) {
      Map.Entry me = (Map.Entry)i.next();
      String sigla=me.getKey();
      Estado estado=me.getValue();
      float x=512*(estado.renda/40000);
      float y=512*(estado.idh/1000);
      float r=5+estado.populacao/1000000;
      fill(regioes[estado.regiao], 100);
      stroke(regioes[estado.regiao], 255);      
      ellipse(x, 512-y, r, r);
    }
  }
O programa desenha um círculo para cada estado. A posição no eixo horizontal indica a renda (quanto mais à direita, maior a renda per capita) e a posição no eixo vertical indica o IDH (quanto mais alto, maior o índice de desenvolvimento humano). O raio do círculo indica a população do estado. As cores representam as regiões: verde para norte;  laranja para nordeste;  amarelo para centro-oeste; vermelho para sudeste; e azul para sul).

Aquele ponto amarelo disparado na frente é o Distrito Federal, evidentemente. O grande ponto vermelho que o precede é São Paulo (que, tendo uma renda per capita bastante maior que a dos estados do sul, não consegue superá-los no IDH).

Pode-se constatar que os pontos aglomeram-se conforme as cores. Minas Gerais é uma exceção que se destaca, assim como o Distrito Federal.

Com pequenas alterações no método draw(), consegui inserir as siglas dos estados dentro dos círculos.

  void setup() {
    size(1024,1024);
    background(255);
    noLoop();
  }

  void draw() {
    Iterator i = estados.entrySet().iterator();
    while (i.hasNext()) {
      Map.Entry me = (Map.Entry)i.next();
      String sigla=me.getKey();
      Estado estado=me.getValue();
      float x=1024*(estado.renda/40000);
      float y=1024*(estado.idh/900);
      float r=20+estado.populacao/1000000;
      fill(regioes[estado.regiao], 100);
      stroke(regioes[estado.regiao], 255);      
      ellipse(x, 1024-y, r, r);
      fill(#FFFFFF, 255);
      text(sigla, x-8, 1028-y);
    }
  }

Tive que aumentar as dimensões do gráfico, para que as siglas não se atropelassem (ainda mais).

Clique na imagem para vê-la aumentada.

Concluí, então, que Processing.js é uma ferramenta deveras interessante e prática. Acho que o próximo passo é investigar as facilidades de animação e interação com o usuário. O fato de rodar no navegador permite jogar o processamento para o cliente.

segunda-feira, 28 de março de 2011

Quatro dimensões em duas

O gráfico do último artigo tinha três dimensões (população, renda e longevidade) comprimidas nas duas dimensões de uma imagem. Neste, vou adicionar mais uma: educação.

O eixo horizontal representa as populações. Portanto, as maiores cidades estão mais à direita. O eixo vertical representa a renda. Logo, as cidades mais ricas estão mais altas que as mais pobres. A longevidade apareceu como cor: quanto mais claro o círculo, mais experiente a população.

Como todas as cidades foram representadas por círculos com o mesmo raio (6 pontos), resolvi usar o tamanho de cada círculo para indicar o índice de educação. A diferença entre o maior e o menor índices é de 0,188. Para simplificar, simplesmente multiplico a diferença entre cada índice e o menor (0,763) por 100. O resultado são raios entre 4 e 18 que, não sendo proporcionais, pelo menos realçam as diferenças.

A consulta é a seguinte:


select 'fill(0,'||w||',0);ellipse('||x||','||y||','||d||','||d||');' 
from (  
  select trunc(log(10,habitantes)*100)-300 x,
         500-trunc(avg(renda)*500) y,
         trunc(avg(longevidade-0.651)*1000) w,
         trunc(avg(educacao-0.763)*100) d
  from municipios
  group by trunc(log(10,habitantes)*100)-300
)
order by d desc

Usei verde para tornar o gráfico mais interessante. Além disso, ordenei os índices em ordem descendente para que os círculos maiores não fossem desenhados sobre os menores.

O resultado é a imagem abaixo:


Aparentemente, a educação melhora a renda. Ou talvez seja o contrário.

quinta-feira, 24 de março de 2011

Renda e longevidade

Depois de gerar um gráfico para relacionar renda com população das cidades gaúchas, resolvi adicionar mais uma dimensão: a longevidade.

Para demonstrar a longevidade, resolvi usar cor. No gráfico anterior, usei linhas para mostrar o nível de renda. Neste, usei círculos. As alturas refletem a renda, como no gráfico anterior, e a cor indica a longevidade da população.


select 'fill('||w||');ellipse('||x||','||y||',6,6);' from (  
  select trunc(log(10,habitantes)*100)-300 x,
         500-trunc(avg(renda)*500) y,
         trunc(avg(longevidade-0.651)*1000) w
  from municipios
  group by trunc(log(10,habitantes)*100)-300
)

Como a longevidade varia de 0,651 a 0,879, usei a diferença entre cada índice e o mínimo para realçar as diferenças. Caso contrário, todas sairiam com um cinza parecido e o gráfico não seria nada interessante.

A consulta produz linhas com o seguinte formato:


fill(117);ellipse(72,176,6,6);


E o resultado é a imagem que segue:

Parece-me que quanto maior a cidade, maior deve ser a renda para que aumente a longevidade.

segunda-feira, 21 de março de 2011

Processando...

Nos anos 1980, Logo era usada para ensinar matemática e programação para crianças. As que tomaram gosto pela coisa devem agora estar brincando com Processing, caso não tenham crescido nessas três décadas.

Graças a uma exibição interessantísima, resolvi provar um pouco desse novo brinquedo. Construída sobre Java, a linguagem aparentemente não acrescenta grandes coisas. Mas as aparências enganam muito!

Comecei buscando um conjunto de dados interessantes. Encontrei uma tabela de desenvolvimento social dos municípios do Rio Grande do Sul. A consulta abaixo gera comandos que uso no Processing para criar um gráfico.


select 'line('||x||',500,'||x||','||y||');' from (
  select trunc(log(10,habitantes)*100)-300 x, 500-trunc(avg(renda)*500) y
  from municipios
  group by trunc(log(10,habitantes)*100)-300
)

Para que a imagem não ficasse muito grande, comprimi os índices de renda (que variam de 0 a 1 com 3 casas de precisão) em 500 valores. O gráfico que quero gerar relaciona renda per capita com número de habitantes. Para gerar o eixo dos habitantes tirei o logarítmo do número de habitantes e o multipliquei por 100. Assim, tenho coordenadas que variam de 300 (para cidades com milhares de habitantes) até 600 (para cidades com milhões de habitantes). Eu tiro a média da renda e agrupo por ela porque pode haver mais de uma cidade com uma determinada ordem de grandeza de habitantes.

O objetivo da consulta é gerar uma lista de comandos desse tipo:


line(55,500,55,211);
line(108,500,108,174);
line(100,500,100,192);
line(35,500,35,231);
line(123,500,123,195);

Claro, preciso de um pouco mais. Mas Processing facilita tanto a brincadeira, que só preciso do seguinte para completar o meu programa:


size(350,400, JAVA2D);
background(#ffffff);
fill(0);
//Comandos do select
saveFrame("/tmp/idh.png");



O resultado é a imagem abaixo.


Tudo indica que quem quer ficar rico deve procurar uma cidade maior e que quem quer se divertir deve aprender Processing.