Introdução a gráficos 3D com Matplotlib

Antes de começarmos a criar gráficos 3D com a biblioteca Matplotlib precisamos habilitar o módulo tollkit da biblioteca. Para habilitar esse módulo precisamos importar a biblioteca mplot3d. Não se preocupe se você não instalou essa biblioteca, por padrão ela já vem com a biblioteca matplotlib. Apenas uma ressalva quanto a isso: verifique se a versão do Matplotlib é igual ou superior à versão 1.0.
Quando o módulo já tiver sido importado, é fácil criar um gráfico 3D apenas passando o valor '3d' para o parâmetro projection de qualquer método para a criação de eixos do matplotlib. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d

import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
eixos = plt.axes(projection="3d")
    
plt.show()

Com os nossos eixos criados já podemos começar a fazer desenhos nesses eixos. Os métodos para criar gráficos em três dimensões são muito similares aos métodos para criar gráficos em 2D, a diferença é a terminação do método que termina com 3d. Outra diferença é o número de argumentos, ao invés de passar apenas dois argumentos passaremos três, um para cada eixo. Os outros parâmetros permanecem os mesmo, como os parâmetros para alterar a cor e a linha dos gráficos. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
eixos = plt.axes(projection="3d")
    
z_line = np.linspace(0, 15, 1000)
x_line = np.cos(z_line)
y_line = np.sin(z_line)
eixos.plot3D(x_line, y_line, z_line, 'gray')
    
pontos_z = 15 * np.random.random(100)
pontos_x = np.cos(pontos_z) + 0.1 * np.random.randn(100)
pontos_y = np.sin(pontos_z) + 0.1 * np.random.randn(100)
eixos.scatter3D(pontos_x, pontos_y, pontos_z, c=pontos_z, cmap='viridis');
    
plt.show()

Assim como os gráficos 2D, podemos mover o gráfico 3D, dar zoom ou mudar o ângulo de visão.

Gráficos de superfície

Os gráficos de superfície são usados para visualizar um conjunto de três variáveis num cenário 3D. Com esse tipo de gráfico é possível visualizar como o valor de um eixo em relação aos outros dois. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
ax = plt.axes(projection="3d")
    
ax = plt.axes(projection='3d')
    
def funcao_z(x, y):
    return np.sin(np.sqrt(x ** 2 + y ** 2))
    
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)
    
X, Y = np.meshgrid(x, y)
Z = funcao_z(X, Y)
    
ax.plot_wireframe(X, Y, Z, color='green')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
    
ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                    cmap='viridis', edgecolor='none')
ax.set_title('Gráfico de superfícies');
    
plt.show()

Anterior Próximo

Read More

Gráficos de fluxo com Matplotlib

Um gráfico de fluxo é um tipo de gráfico 2D usado para mostrar fluxo de fluido e gradientes de campo 2D.
O método básico para criar um gráfico de fluxo no Matplotlib é:
ax.streamplot(x_grid,y_grid,x_vec,y_vec, density=espacamento)
Onde x_grid e y_grid são matrizes dos pontos x, y. As matrizes x_vec e y_vec denotam a velocidade do fluxo em cada ponto da grade. O argumento do parâmetro density=espacamento especifica a proximidade das linhas de fluxo.

Um gráfico de fluxo simples

Vamos começar com um gráfico de fluxo que contém linhas de fluxo em uma grade 10 x 10. Todas as linhas de fluxo no gráfico são paralelas e apontam para a direita.
A seção de código a seguir cria um gráfico de fluxo que contém linhas paralelas horizontais apontando para a direita.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,10)
y = np.arange(0,10)
    
X, Y = np.meshgrid(x,y)
u = np.ones((10,10)) # x-component to the right
v = np.zeros((10,10)) # y-component zero
    
fig, ax = plt.subplots()
    
ax.streamplot(X,Y,u,v, density = 0.5)
ax.set_title('Gráfico de fluxo com linhas pararelas')
plt.show()

O gráfico contém linhas de fluxo paralelas, todas apontando para a direita.

Gráfico de fluxo de um campo

Podemos construir um gráfico de fluxo que mostra linhas de campo com base em um campo vetorial 2D definido.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,2.2,0.1)
y = np.arange(0,2.2,0.1)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(y)*Y
    
fig, ax = plt.subplots()
    
ax.streamplot(X,Y,u,v, density = 1)
ax.axis([0.5,2.1,0,2])
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.set_title('Gráfico de fluxo com linhas de campo')
    
plt.show()

Anterior Próximo

Read More

Gráfico de setas com Matplotlib

Gráfico de aljavas

Um gráfico de aljavas é um tipo de gráfico 2D que mostra linhas vetoriais como setas. Os gráficos com setas são úteis na Engenharia Elétrica para visualizar o potencial elétrico e útil na Engenharia Mecânica para mostrar gradientes de tensão.

» Gráfico de aljavas com uma seta

Primeiro, criaremos um gráfico de aljavas simples que contém uma seta para demonstrar como o método quiver() da biblioteca Matplotlib funciona. O método quiver() usa quatro argumentos posicionais:

Exemplo Python

ax.quiver(x_pos, y_pos, x_direct, y_direct)

x_pos e y_pos são as posições iniciais da seta e x_direct, y_direct são as direções da seta (pra onde a seta aponta).
Nosso primeiro gráfico contém uma seta no ponto inicial x_pos = 0, y_pos = 0. A direção da flecha está apontando para cima e para a direita x_direct = 1, y_direct = 1.
O exemplo de código a baixo cria um gráfico de aljavas com apenas uma seta.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
fig, ax = plt.subplots()
    
x_pos = 0
y_pos = 0
x_direct = 1
y_direct = 1
    
ax.quiver(x_pos, y_pos, x_direct, y_direct)
ax.set_title('Gráfico de aljavas com uma seta')
    
plt.show()

Executando o código acima o seu gráfico deve esta assim:

Nesse exemplo o gráfico de aljava contém uma seta. A seta começa no ponto 0, 0 e termina no ponto 1, 1.

» Gráfico de aljavas com duas setas

Agora vamos adicionar uma segunda seta ao gráfico de aljava passando em dois pontos de partida e duas direções de seta.
Manteremos nossa posição inicial da seta original na origem 0,0 e apontando para cima e para a direita (na direção 1,1). Definiremos uma segunda seta com uma posição inicial de -0,5,0,5, que aponta diretamente para baixo (na direção 0, -1).
Um argumento de palavra-chave adicional para adicionar o método quiver() é scale=5. Incluir o parâmetro scale=5 dimensiona o comprimento das setas, para que as setas pareçam mais longas e apareçam melhor no gráfico de aljava.
Para ver o início e o fim de ambas as setas, definiremos os limites do eixo entre -1,5 e 1,5 usando o método ax.axis() e passaremos uma lista dos limites do eixo no formato [xmin, xmax, ymin, ymax] .
Executando o exemplo abaixo, podemos ver duas setas. Uma seta aponta para o canto superior direito e a outra seta aponta para baixo.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
fig, ax = plt.subplots()
    
x_pos = [0, 0]
y_pos = [0, 0]
x_direct = [1, 0]
y_direct = [1, -1]
    
ax.quiver(x_pos, y_pos, x_direct, y_direct, scale=5)
ax.axis([-1.5, 1.5, -1.5, 1.5])
    
plt.show()

Nesse exemplo podemos ver um gráfico com duas setas. Ambas as setas começam no ponto 0,0. Uma seta aponta para o canto superior direito, a outra seta aponta para baixo.

» Gráfico de aljavas usando uma grade de malha

Um gráfico de aljava com duas setas é um bom começo, mas é entediante e repetitivo adicionar as flechas de aljava uma a uma. Para criar uma superfície 2D completa de setas, utilizaremos a função meshgrid() da biblioteca NumPy.
Primeiro, precisamos criar um conjunto de matrizes que denotem as posições iniciais x e y de cada seta no gráfico. As matrizes da posição inicial da seta serão denominadas X e Y.
Podemos usar as posições iniciais da seta x, y para definir os componentes x e y de cada direção da seta. Chamaremos a direção da seta u e v. Para esse gráfico, definiremos a direção da seta com base no ponto inicial da seta da aljava usando as equações abaixo.

X_direção = COS(X_{posição_inicial})
Y_direção = SIN(Y_{posição_inicial})

A seção de código abaixo cria as matrizes das posições X e Y usando a função np.meshgrid() da biblioteca NumPy.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,2.2,0.2)
y = np.arange(0,2.2,0.2)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X) * Y
v = np.sin(y) * Y

Em seguida, podemos construir o gráfico de aljava usando o método quiver() do Matplotlib. Lembre-se de que o método quiver() aceita quatro argumentos posicionais:

ax.quiver(x_pos, y_pos, x_direct, y_direct)

Nesse gráfico de aljava, x_pos e y_pos são matrizes 2D que contêm as posições iniciais das setas e x_direct, y_direct são matrizes 2D que contêm as direções das setas.
Os comandos ax.xaxis.set_ticks([]) e ax.yaxis.set_ticks([]) remove as marcas de seleção do eixo e ax.set_aspect('equal') define a proporção da plotagem para 1:1.

Exemplo Python

fig, ax = plt.subplots(figsize=(7,7))
ax.quiver(X,Y,u,v)
    
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([-0.2, 2.3, -0.2, 2.3])
ax.set_aspect('equal')
    
plt.show()

Agora vamos construir outro gráfico de aljava em que os componentes Î e ĵ (a direção) das setas de força, ⃗F dependem do ponto inicial da seta x, y de acordo com a função:

Novamente, usaremos a função meshgrid() do NumPy para criar as matrizes da posição inicial da seta e aplicar nossa função ⃗F às matrizes do ponto inicial da seta X e Y.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(-1,1,0.1)
y = np.arange(-1,1,0.1)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(Y)*Y
    
X,Y = np.meshgrid(x,y)
    
u = X/5
v = -Y/5
    
fig, ax = plt.subplots(figsize=(9,9))
    
ax.quiver(X,Y,u,v)
    
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.set_aspect('equal')
    
plt.show()

Anterior Próximo

Read More

Gráficos de contorno com Matplotlib

Com a biblioteca Matplotlib podemos criar gráficos de contorno de uma maneira muita rápida. Um gráfico de contorno pode ser muito útil em algumas áreas, como na engenharia Civil. Na engenharia Civil um gráfico de contorno pode mostrar o contorno de uma construção ou elevação. Já na engenharia Mecânica o mesmo tipo de gráfico pode mostrar um gradiente de tensão na superfície de uma peça.

Método plt.contourf()

Para podermos criar um gráfico de contorno precisaremos necessariamente usar o método contour(). Um exemplo de como chamar o método contour() pode ser visto abaixo:

Exemplo Python

ax.contour(X, Y, Z)

X, Y e Z são matrizes 2D com os seus elementos representando um ponto do gráfico. As arrays X e Y são pontos de coordenadas de x e y. Já a array Z é uma matriz que determinada a altura do contorno. Essa representação é feita num gráfico 2D através de uma cor.
No exemplo abaixo vamos utilizar a função np.meshgrid() para criarmos duas arrays 2D utilizando uma matriz 1D.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o Jupyter notebook, inclua:
# %matplotlib inline
        
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6, 6))
        
ax.contour(X, Y, Z)
        
plt.show()

Ao executar o código acima você deve ter como resultado um gráfico como esse:

Método plt.contourf()

O método contourf() da biblioteca Matplotlib é semelhante ao método contourf(), a única diferença entre esses dois métodos é que o primeiro método criar um gráfico preenchido e o segundo não. Para chamar o método contourf passamos os mesmos parâmetros que passamos para o método contour. Veja um exemplo abaixo:

Exemplo Python

ax.contourf(X, Y, Z)
    

X e Y são arrays 2D dos pontos x e y, e Z é uma matriz 2D de pontos que determina a cor das áreas no gráfico 2D.
A próxima parte do código cria uma gráfico de contorno sombreada usando o método contourf() da biblioteca Matplotlib.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver utilizando o Jupyter notebook, use:
# %matplotlib inline
        
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
ax.contourf(X,Y,Z)
        
plt.show()

Executando esse código o seu gráfico deve estar igual a este:

Barras coloridas no gráfico de contorno

Nos gráfico de contorno utilizamos as cores parar representar uma determinada altura, mas sem saber a qual altura uma cor representar isso não é muito útil. Para resolver esse problema, nos gráficos de contornos, normalmente é adicionada uma barra colorida representando a altura. Essa barra funciona como uma legenda do gráfico.
As barras de cores utilizadas nos gráficos de contorno são adicionadas com o método colorbar(). Por essa barra não pertencer ao gráfico ela precisa ser adicionada. Para fazer isso passamos um gráfico de contorno para o método colorbar(). Assim, toda vez que você precisar adicionar uma barra de cores a um gráfico, um objeto plot precisar estar disponível. E a saída do método contourf() é um objeto plot.
Nos exemplos anteriores, a saída do método contourf() não era atribuída a nenhuma variável. Mas, para adicionar uma barra de cores no nosso gráfico, vamos precisar da saída desse método. Assim podemos passar um objeto plot para o método colorbar().

Exemplo Python

cf = ax.contourf(X,Y,Z)
fig.colorbar(cf, ax = ax)

cf é o objeto plot criado pelo método contourf(). O objeto eixocontém o gráfico de contorno, ax é passado para o método colorbar()junto com o objeto plot.

Executando o exemplo abaixo criamos um gráfico de contorno preenchido com uma barra de cores posicionada ao lado do gráfico.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
ax.set_aspect('equal')
cf = ax.contourf(X,Y,Z)
fig.colorbar(cf, ax = ax)
        
plt.show()

Executando código acima o gráfico é esse:

Mapas de cores

O esquema de cores usado nos gráficos de contornos podem ser mudados. O método mais rápido de se fazer isso é usando o método get_cmap() da biblioteca Matplotlib. Na biblioteca Matplotlib existem vários mapas de cores que você pode usar nos seus gráficos. Para ver quais mapas de cores estão disponíveis acesse a documentação da biblioteca (https://matplotlib.org). Já com o mapa de cores precisamos passar esse objeto para o método ou contourf().

Exemplo Python

meu_mapc = plt.get_cmap('gist_earth')
ax.contourf(X, Y, Z, cmap = meu_mapc)

No exemplo abaixo vamos alterar a cor padrão dos gráficos de contorno.

Exemplo Python

import matplotlib.pyplot as plt
import numpy as np
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
meu_mapc = plt.get_cmap('plasma')
ax.set_aspect('equal')
ax.set_title('Mapa de cores: plasma')
cf = ax.contourf(X,Y,Z, cmap = meu_mapc)
        
fig.colorbar(cf, ax = ax)
        
plt.show()

Executando esse código o seu gráfico deve estar igual a este:

Anterior Próximo

Read More

Visualizando um campo escalar 2D

As bibliotecas matplotlib e numpy nos fornecem algumas funções uteis para a visualização de um campo escalar em 2D. Nesse tutorial vamos aprender como visualizar um campo escalar 2D de um jeito muito simples.

Como visualizar um campo escalar 2D com o Matplotlib

Para visualizar um campo escalar 2D vamos utilizar a função meshgrid, da biblioteca numpy, e a pcolormesh, da biblioteca matplotlib. A função meshgrid retorna matrizes com vetores de coordenadas. E a função pcolormesh, é chamada para mostrar a função. Veja um exemplo abaixo usando as duas funções:

Exemplo

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

x = np.linspace(-3, 3, 51)
y = np.linspace(-2, 2, 41)
X, Y = np.meshgrid(x, y)

Z = (1 - X/2 + X**5 + Y**3) * np.exp(-X**2 - Y**2)

plt.pcolormesh(X, Y, Z, cmap = cm.viridis)
plt.colorbar()

plt.show()

Executando o código acima o seu gráfico deve estar igual a este:

Nesse exemplo fica claro como uma boa escolha de cores pode ajudar na analise de dados. Na imagem os valores negativos aparecem com uma tonalidade mais para o azul e os valores positivos mais para o amarelo.

Como funciona...

A função meshgrid recebe duas coordenadas x e y, e retorna dois grids com as coordenadas de x e y. E a função pcolormesh recebe as variáveis x, y e z, assim obtemos as coordenadas corretas. A função pcolormesh é chamada para renderizar o gráfico com as coordenadas recebidas, o mesmo resultado pode ser alcançado utilizando a função imshow.

Anterior Próximo

Read More

Adicionando legenda do colormap

Uma coisa indispensável em muitos gráficos, e que ainda não aprendemos, é adicionar uma legenda do mapa de cores. Uma legenda do mapa de cores pode tornar o seu gráfico mais legível e visualmente mais agradável. Claro que a estética é uma das últimas preocupações quando estamos criando um gráfico. O que realmente gostaríamos de mostra, quando adicionamos uma legenda ao mapa de cores, é o valor que cada cor representa no gráfico. Nesse tutorial vamos aprender como adicionar uma legenda do colormap com a biblioteca matplotlib.

Como adicionar legendas do colormap

Para esse exemplo vamos criar uma matriz 2d com valores aleatórios e adicionar uma legenda ao colormap. Veja como fazer isso no exemplo abaixo:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

matriz = np.random.random((100,100))
plt.imshow(matriz, origin = 'lower', cmap = 'viridis', interpolation = 'nearest')

cb = plt.colorbar(orientation = 'horizontal', shrink = .75)
cb.set_label('Legenda do colormap')

plt.show()

Executando o código acima o seu gráfico deve ficar parecido com esse:

Com essa barra e a legenda é possível saber qual valor uma determinada cor representa.

Como funciona…

Com o método colorbar dizemos a biblioteca matplotlib que queremos adicionar uma barra ao nosso gráfico. Para facilitar o entendimento, adicionamos alguns parâmetros adicionais ao método colorbar. O parâmetro orientation define a orientação da barra, o padrão desse parâmetro é vertical. Nesse caso escolhemos horizontal, para deixar a barra na vertical é só omitir esse parâmetro. Com o parâmetro shrink definimos o quanto a barra deve ser encolhida com base no seu tamanho padrão. Já para adicionar a legenda precisamos criar um objeto colorbar e chamar o método set_label, passando como argumento o texto da legenda que queremos adicionar a barra.

Anterior Próximo

Read More

Mais sobre o método imshow

Mais sobre o método imshow do Matplotlib

Com o exemplo do tutorial anterior, obtivemos alguns resultados preliminares. Nesse exemplo é possível notar que os eixos usados no gráfico são os indexes da matriz 2d que passamos para o método imshow. É possível que você queira usar outros eixos. Para fazer essa alteração precisamos passar os novos valores para o parâmetro extent. Nesse exemplo vamos utilizar os valores do quadro de amostra do mandelbrot. Para evitar digitar código repetido vamos apenas mudar a chamada a função imshow do tutorial passado, veja como fica a nova chamada ao método imshow:

Exemplo

plt.imshow(mandelbrot, cmap = cm.viridis, extent = (x_min, x_max, y_min, y_max))

Executando o código do tutorial anterior com as alterações no método imshow, que fizemos nesse tutorial, o gráfico gerado deve ser igual a esse:

Como funciona…

Quando passamos valores para o parâmetro opcional extent especificamos o sistema de coordenados que deve ser usado para renderizar os dados da matriz 2d. O parâmetro extent recebe uma tupla com quatro valores. Os dois primeiros valores da tupla devem ter os valores mínimos e máximos do eixo horizontal. E os dois últimos valores devem ter os valores do eixo vertical. Fazendo essa alteração os eixos mostram os valores que usamos para calcular o conjunto de mandelbrot.

Anterior Próximo

Read More

Visualizando o conteúdo de uma matriz 2D

Introdução

Até o momento, criamos gráficos que representam dados unidimensionais. Com esses dados fomos capazes de traçar algumas primitivas. Quando desenhamos mapas é possível visualizar a influência que dois dados tem sobre um terceiro. Imagine que você tem algumas fazendas espelhadas pelo país. Com uma rápida olhada num mapa seria possível saber qual produto cada região do país produz, de acordo com os dados de produção de suas fazendas. A biblioteca matplotlib nos fornece uma API simples para a criação mapas.

Visualizando uma matriz 2D

Nesse exemplo vamos começar com um projeto bem simples. Tudo o que queremos é visualizar o conteúdo de uma matriz 2D. E a matriz que vamos utilizar é o conjunto de Mandelbrot. O conjunto de Mandelbrot é um fractal definido como o conjunto de pontos x no plano complexo para o qual a sequência é definida recursivamente: não tende ao infinito. Para cada ponto x do plano complexo, a sequência se expande indefinidamente.

Como visualizar o conjunto de Mandelbrot

Para visualizar uma matriz 2D, primeiro precisamos criar uma matriz 2d com os valores do mandelbrot e depois precisamos chamar o método imshow passando a matriz para o método. Veja um exemplo abaixo:

Exemplo

import numpy as np
import matplotlib.cm as cm
from matplotlib import pyplot as plt

def iter_count(C, i_max):
  X = C
  for n in range(i_max):
    if abs(X) > 2.:
      return n
    X = X ** 2 + C
  return i_max

N = 512
i_max = 64
x_min, x_max, y_min, y_max = -2.2, .8, -1.5, 1.5

X = np.linspace(x_min, x_max, N)
Y = np.linspace(y_min, y_max, N)
mandelbrot = np.empty((N, N))

for i, y in enumerate(Y):
  for j, x in enumerate(X):
    mandelbrot[i, j] = iter_count(complex(x, y), i_max)

plt.imshow(mandelbrot, cmap = cm.viridis)
plt.show()

Por ser um exemplo que precisa de muito processamento, esse exemplo pode demorar um pouco para mostrar o seu resultado. Mas o resultado vai ser um fractal de Mandelbrot, igual a este:

Como funciona a função imshow

O funcionamento do método imshow é muito simples. O método recebe uma matriz 2d e para cada elemento dessa matriz o método cria um pixel. A cor do pixel é escolhida entre os valores de um mapa de imagens (no nosso caso usamos o viridis). Apesar do métod imshow criar a imagem ela não a mostra, por isso precisamos chamar o método show.

Anterior Próximo

Read More

Criando um arquivo pdf com várias páginas

Nos tutoriais anteriores aprendemos como criar um gráfico com vários gráficos. Assim criamos um gráfico com várias imagens utilizando a biblioteca matplotlib. Desse modo podemos criar gráficos cada vez mais complexos. Desse modo é compreensível pensar que, se utilizamos a biblioteca matplotlib para exportar esse gráfico composto para um arquivo pdf, teríamos um arquivo pdf com uma pagina com vários gráficos. Mas com apenas um pouco de esforço podemos mudar essa realidade e criar um arquivo pdf com algumas páginas. Uma coisa importante de se ter em mente é que o matplotlib é uma biblioteca de plotagem cientifica e não um sistema de composição de documentos como é o caso do LaTeX. Nesse tutorial vamos aprender como criar um documento pdf com algumas páginas.

Exemplo

import datetime
import numpy as np
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt

# Cria um objeto PdfPages com o qual salvaremos as páginas:
# A instrução with garantimos que o objeto PdfPages seja fechado corretamente
# no final, mesmo que ocorra uma exceção.
with PdfPages('multiplas_paginas_pdf.pdf') as pdf:
  plt.figure(figsize = (3, 3))
  plt.plot(range(7), [3, 1, 4, 1, 5, 9, 2], 'r-o')
  plt.title('Página Um')
  pdf.savefig() # salva a imagem atual numa pagina do pdf
  plt.close()

  # Se LaTeX não estiver instalado vai causar um erro
  # Nesse caso mude usetex para False
  plt.rc('text', usetex = True)
  plt.figure(figsize = (8, 6))
  x = np.arange(0, 5, 0.1)
  plt.plot(x, np.sin(x), 'b-')
  plt.title('Página Dois')
  pdf.attach_note("Curva de sin(x)") # você pode adicionar uma nota ao pdf
  pdf.savefig()
  plt.close()

  plt.rc('text', usetex = True)
  fig = plt.figure(figsize = (4, 5))
  plt.plot(x, x ** 2, 'ko')
  plt.title('Página Três')
  pdf.savefig(fig) # Você pode passar um objeto figure para o método savefig
  plt.close()

  # tambem podemos adicionar metadados do arquivo pdf com o objeto PdfPages
  d = pdf.infodict()
  d['Title'] = 'Exemplo Com Múltiplas páginas'
  d['Author'] = 'Acervo Lima'
  d['Subject'] = 'Como criar um arquivo pdf com mútiplas páginas'
  d['Keywords'] = 'PdfPages multipage keywords'
  d['CreationDate'] = datetime.datetime(2020, 5, 13)
  d['ModDate'] = datetime.datetime.today()

Executando o código acima um arquivo pdf com três páginas deve ser criado na pasta do script.

Anterior Próximo

Read More

Criando PDF e SVG com Matplotlib

Algumas vezes o que você quer não é um arquivo bitmap como o PNG. O que um arquivo bitmap faz é criar uma matriz de pontos que representam uma imagem. Se você olhar a imagem mais de perto (dar zoom), você vai ver esses pontos e a imagem começa a perder a forma. E isso se torna mais evidente dependendo do algorítimo de amostragem. Para mudar isso podemos usar imagens vetoriais, que são invariáveis independente da escala. Não importa a escala que a imagem esteja sendo visualizada, a figura continua a mesma, com a mesma qualidade de detalhes. Por essa e outras propriedades as imagens vetoriais são usadas em documentos maiores, sem precisar criar uma nova imagem com uma resolução maior, como fizemos no tutorial anterior. Com a biblioteca matplotlib podemos criar imagens vetoriais, como imagens em PDF e SVG.

Como criar uma arquivo pdf com Matplotlib

Criar um arquivo pdf com a biblioteca matplotlib é uma tarefa fácil. Veja no exemplo a baixo como isso é feito:

Exemplo

import numpy as np
from matplotlib import pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.scatter(coordenadas[:,0], coordenadas[:,1], color = (1., 0., .40))
plt.savefig('imagem.pdf')

Executando esse código um arquivo pdf vai ser criado na mesma pasta do script. A imagem do arquivo pdf deve ser parecida com essa:

Como funciona…

Já estudamos o método savefig anteriormente. Utilizamos esse método para criar um arquivo png no tutorial anterior. Com esse método apenas passar o nome do arquivo já é suficiente para definir se um arquivo será um PNG, PDF ou SVG. Tudo que você precisa fazer é passar a extensão do arquivo que você deseja criar. A biblioteca matplotlib vai ver a extensão do arquivo e criá-lo.

Anterior Próximo

Read More

Controlando a resolução da imagem

Se não alterarmos as configurações da biblioteca matplotlib, quando criamos uma imagem de bitmap, a biblioteca define o tamanho e a resolução da imagem. Para a maioria dos usos dessas imagens, o tamanho e a resolução escolhidos pela biblioteca matplotlib vai servir para a maioria das situações. Mas o matplotlib nos permite definir essas propriedades por conta própria. Por exemplo, se você precisar criar uma imagem para ser usada num cartas é interessante que a resolução dessa imagem seja grande. Outro cenário é utilizar essa imagem como uma miniatura, nessa caso a resolução não precisar ser tão alta. Nesse tutorial vamos aprender a definir a resolução das imagens.

Como definir a resolução de uma imagem

O método savefig nos permite definir a resolução de uma imagem através do parâmetro opcional dpi. Veja uma exemplo de utilização do parâmetro dpi:

Exemplo

import numpy as np
from matplotlib import pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.scatter(coordenadas[:,0], coordenadas[:,1])
plt.savefig('imagem.png', dpi = 350)

Nesse exemplo, criamos um gráfico com vários pontos. Como passamos o valor 350 para o parâmetro dpi, a imagem tem uma resolução de 2240 pixels por 1680 pixels. Veja a imagem abaixo, é quase a mesma do exemplo passado, a diferença é a resolução que é muito maior:

Como funciona…

Com o parâmetro dpi podemos controlar a resolução da imagem. Esse parâmetro recebe o valor da resolução em DPI (pontos por polegadas). Para aqueles que não utilizam a polegada como uma metida padrão, uma polegada equivale a dois vírgula cinquenta e quatro centímetros. Essa medida define que em uma polegada da imagem teremos uma certa quantidade de pontos. Para a maioria das impressoras à jato de tinta a qualidade máxima da resolução é trezentos pontos por polegadas.

Anterior Próximo

Read More

Trabalhando com transparência

Quando criamos uma imagem é muito difícil que pretendemos usar essa imagem isolada, sempre teremos outras imagens ou outros elementos acompanhando ela. Por exemplo, essa imagem pode ser parte de uma apresentação ou até mesmo uma imagem de um site. E em alguns desses casos é preciso que os elementos da imagem sejam integrados com outros elementos. E uma coisa indispensável para essa integração é a transparência. Assim os elementos de um gráfico podem ser integrados com outros elementos de forma mais homogenia. Nesse tutorial vamos aprender a criar imagens com transparência.

Como criar uma imagem com transparência com a biblioteca matplotlib

Um ótimo jeito de observar a transparência de uma imagem é adicioná-la a uma pagina web. Porque a imagem transparente vai se misturar com o fundo da página web. Uma coisa importante é que todos os arquivos desse tutorial devem estar na mesma pasta. Porque nesse tutorial vamos criar uma imagem com transparência e criar uma pagina web que incluí essa imagem como um dos elementos que compõem a página.

Criando uma imagem PNG com o fundo transparente

Para criamos uma imagem com transparência vamos usar a o método savefig, como já usamos antes. Mas dessa vez vamos definir o parâmetro transparent como True.

Exemplo

import numpy as np
from matplotlib import pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.scatter(coordenadas[:,0], coordenadas[:,1])
plt.savefig('imagem-1.png', transparent = True, c = (0., .40, 1.))

Criando uma pagina web para adicionar a imagem

Agora vamos criar uma pagina web com um background e usar a imagem com transparência nessa pagina web. Copie e cole o codigo html abaixo em um editor de sua preferência e salve com a extensão html:

Exemplo

<html>
  <!--Define a cor de fundo como sendo cinza. Experimente mudar para Red-->
  <body style="background-color:LightGray;">
    <img src="imagem-1.png" width="640" height="480"></img>
  </body>
</html>

Abrindo o arquivo html, que acabamos de criar, no navegador você deve ter um resultado parecido com o exemplo mostrado abaixo. Note como a imagem com o fundo transparente se mescla com a pagina web.

Como funciona…

O método savefig, por padrão, não adiciona informações de transparência na imagem PNG. Mudamos esse comportamento passando o valor True para o parâmetro transparent.

Anterior Próximo

Read More

Criando um arquivo png

Introdução

Como a maioria das figuras técnicas, as figuras cientificas não são apresentadas de forma independente, geralmente essas figuras são uma parte de um documento maior. A biblioteca matplotlib pode exportar os gráficos criados para alguns do formatos mais utilizados, como SVG, PNG, EPS, e PDF. Todas as vezes que criamos um gráfico, a biblioteca matplotlib mostra esse gráfico com uma interface que permite salvar a imagem do gráfico. Para um punhado de gráficos essa abordagem pode ser valida, mas quando falamos de um número muito maior de imagens essa abordagem acaba por se tornar um problema. Principalmente se você precisa criar o mesmo gráfico com alguns valores diferentes. Nos próximos tutoriais vamos aprender a utilizar os recursos de saída de arquivos da biblioteca matplotlib. Como definir o tamanho da imagem, a resolução e a transparência.

Criando uma imagem PNG com a biblioteca matplotlib

Se não alterarmos as configurações da biblioteca matplotlib, todas as vezes que criamos um gráfico ele será mostrado numa janela que nos permite movimentar a imagem, salvar, dar zoom, entre outras coisas. Para a criação de protótipos essa abordagem é muito útil e eficiente, mais quando falamos de usos comuns, isso já não é mais verdade. Por exemplo, criar uma duzia de figuras para serem adicionadas a relatórios gerados automaticamente. Você pode querer criar uma imagem para cada arquivo com dados. E boas noticias, você pode! A biblioteca matplotlib nos permite criar imagens com uma grade flexibilidade.
Para o nosso primeiro exemplo, vamos criar uma imagem no formato PNG. Um arquivo ideal para a saída bitmap é o PNG, isso por ser o padrão de imagens bitmap. O padrão bitmap é suportado pela maioria dos visualizadores de imagens, por ser um algorítimo de compressão sem perdas e suportar a transparência, o que não acontece com o JPEG.

Como criar uma imagem PNG

Para salvar uma imagem no disco, ao invés de mostrar numa janela, trocamos o método show pelo savefig. Assim pedimos que a biblioteca matplotlib salve o arquivo no disco e não mostrá-lo numa janela.

Exemplo

import numpy as np
from matplotlib import pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.scatter(coordenadas[:,0], coordenadas[:,1])
plt.savefig('imagem.png', c = (0., .40, 1.))

Executando esse código, ao invés de mostrar uma janela com o gráfico, é criado uma imagem na mesma pasta do código. Nesse exemplo foi criado uma imagem png com uma resolução de 640×480 pixels. Veja a imagem abaixo:

Como funciona o método savefig

O método savefig funciona de modo semelhante ao método show. A diferença é que o método savefig mostra uma janela com o gráfico e o método savefig cria uma imagem com o mesmo gráfico. A função savefig não cria janelas e sim imagens. Desse modo, todos os comandos funcionam da mesma maneira, independentemente da saída final, seja ela uma janela ou um arquivo.
O método savefig tem vários parâmetros opcionais para modificar a saída do arquivo, veremos esses parâmetros nos próximos tutoriais.

Anterior Próximo

Read More

Coordenadas polares com Matplotlib

Na matemática, uma coordenada polar é utilizado como um sistema de coordenadas bidimensional onde cada ponto no plano é determinado por uma distância e um ângulo em relação a um ponto fixo de referência. Esse ponto de referência é chamado de polo, e a semirreta do polo na direção de referência é chamado de eixo polar.
As coordenadas polares são uma boa escolha para representar dados que se repetem num determinado período de tempo, como numa safra, no ano, ou até mesmo no dia. Nesse tutorial vamos aprender como utilizar coordenadas polares nos nossos gráficos.

Como plotar uma curva polar

No exemplo abaixo vamos criar uma curva polar usando a biblioteca matplotlib:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

a = np.linspace(0 , 2 * np.pi, 1024)

plt.axes(polar = True)
plt.plot(a, 1. + .25 * np.cos(16 * a), c = (.2, 1., .2))
plt.show()

Executando o exemplo acima você deve ter como resultado um gráfico com coordenas polares igual a este:

Como funciona…

Nos exemplos anteriores já criamos objetos axes com o método axes. E sabemos que fazendo isso diretamente podemos personalizar as configurações, como nesse caso onde definimos que a projeção seria polar. Definimos isso passando o valor True para o parâmetro polar.

Tem mais…

O gráfico de projeções polares é muito utilizado para desenhar curvas. Mas podemos utilizar o mesmo tipo de projeção para representar barras ou criar polígonos. Por exemplo, uma coisa interessante que podemos fazer com a projeção polar e utilizando polígonos é um gráfico de radar. Veja como criar um gráfico de radar no exemplo abaixo:

Exemplo

import numpy as np
import matplotlib.patches as patches
import matplotlib.pyplot as plt

axes = plt.axes(polar = True)
teta = np.linspace(0, 2 * np.pi, 8, endpoint = False)
raio = .25 + .75 * np.random.random(size = len(teta))
pontos = np.vstack((teta, raio)).transpose()
plt.gca().add_patch(patches.Polygon(pontos, color = (0., .40, 1.)))
plt.show()

Executando o código acima o seu gráfico deve ficar parecido com esse:

Nesse exemplo as coordenadas do polígono (pontos) são ângulos e a distância do centro. Desse jeito não precisamos fazer conversões de coordenadas polares para cartesianas.

Anterior Próximo

Read More

Escala logarítmica com Matplotlib

Alguns dados podem descrever uma curva pouco perceptível com uma escala geométrica. Tornando a analise dos dados pouco produtiva. Mas felizmente a biblioteca matplotlib nos fornece meios de alterar a escala do gráfico. Assim podemos alterar a escala geométrica do gráfico para uma logarítmica. Desse modo podemos visualizar todo o conjunto de dados, mesmo aqueles que descrevem uma curva exponencial.

Como alterar a escala do gráfico

A biblioteca matplotlib nos permite mudar a escala do gráfico de várias formas. A maneira que vamos utilizar nesse tutorial serve para qualquer tipo de dados, não somente para curvas. Veja como alteramos a escala do gráfico:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

x = range(1, 10)
y = np.exp2(x)

plt.yscale('log')
plt.plot(x, y)
plt.show()

Executando o código acima o seu gráfico deve esta igual a este:

Como funciona…

Nesse exemplo utilizamos a função yscale para alterar a escala do eixo y. Para utilizar uma escala logarítmica passamos o valor ‘log’ para a função. Por padrão a escala logarítmica tem base dez mas podemos alterar esse comportamento com o parâmetro basey. Para alterar a escala do eixo x a função utilizada é a xscale. E o parâmetro para alterar a base usada pela função é o basex.

Anterior Próximo

Read More

Inserindo subfiguras com Matplotlib

Com a biblioteca matplotlib podemos adicionar pequenas figuras ao nosso gráfico. Essas figuras podem ser úteis para mostrar um área do gráfico em zoom ou uma visão mais geral dele. Esse tipo de visualização é muito útil por questão de praticidade. Com esse recurso você não precisa ficar movimentando o gráfico. A área que você precisa ver com detalhe ou uma visão geral pode ser adicionada ao gráfico como uma subfigura. É o que vamos aprender agora nesse tutorial.

Como adicionar subfiguras ao gráfico

A biblioteca matplotlib nos permite criar uma subfigura em qualquer região do gráfico. Nesse exemplo vamos criamos uma subfigura para mostrar uma parte do gráfico:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

cdnd = np.random.rand(100, 2)

plt.scatter(cdnd[:,0], cdnd[:,1])

sub_axes = plt.axes([.6, .6, .25, .25])
sub_axes.scatter(cdnd[:,0], cdnd[:,1], c = (1., 0., .40))
plt.setp(sub_axes)

plt.show()

Executando o código acima o seu gráfico deve esta parecido com esse:

Como funciona…

Nesse exemplo criamos uma representação dos dados com um tamanho do gráfico. E adicionamos esse mini gráfico no próprio gráfico. Para fazer isso primeiro nos criamos uma pequena região no gráfico com a função axes. Depois criamos o mini gráfico com a função scatter do objeto axes. Essa função scatter funciona da mesma maneira da função scatter do objeto pyplot, criando pontos no gráfico. E depois chamamos a função setp. Essa função é utilizada para definir as propriedades do gráfico. Nesse caso um gráfico com uma subfigura.

Anterior Próximo

Read More

Proporção com Matplotlib

Um gráfico pode ser usado em vários lugares diferentes, como num jornal, numa revista ou num web site. E para cada local que o gráfico vai ser usado o espaço pode ser abundante ou escaço. Talvez pra uma publicação num web site você precise que o gráfico seja mais largo do que alto, ou vice-versa, para poder se encachar no espaço disponível. Por isso é importante aprender a modificar a proporção do gráfico. E é isso que vamos aprender a fazer nesse tutorial.

Como mudar a proporção de um gráfico com matplotlib

A biblioteca matplotlib nos fornece uma maneira muito simples de mudar a proporção do gráfico. Com apenas uma função podemos fazer isso. Veja um exemplo abaixo:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

coordenadas = np.random.rand(100, 2)

plt.figure(figsize = (10.24, 2.56))
plt.scatter(coordenadas[:,0], coordenadas[:,1])

plt.show()

Executando o código acima o seu gráfico deve estar parecido com esse:

Como funciona...

O objeto figure é criado toda vez que criamos um gráfico. Mas quando criamos um objeto figure, por conta própria, podemos modificar algumas de suas propriedades. E uma dessas propriedades é a proporção. Nesse exemplo criamos uma figura com uma proporção 4:1. A proporção da figura é definida pelo parâmetro figsize. No exemplo acima passamos uma tupla com os valores em polegadas. O primeiro elemento da tupla define a largura da figura e o segundo a altura.

Anterior Próximo

Read More