Sobrepor Imagem em Gráfico Matplotlib

Beginner

This tutorial is from open-source community. Access the source code

Introdução

Na visualização de dados, por vezes pode querer adicionar um logótipo, marca d'água ou outros elementos de imagem aos seus gráficos. Este tutorial demonstra como sobrepor uma imagem num gráfico Matplotlib, colocando-a em frente ao conteúdo do gráfico e tornando-a semi-transparente.

Aprenderá a usar o método figimage da classe matplotlib.figure.Figure para posicionar uma imagem no seu gráfico, e o método imread do módulo matplotlib.image para carregar dados de imagem.

No final deste tutorial, será capaz de criar visualizações com aspeto profissional com sobreposições de imagem personalizadas que podem ser úteis para branding, marca d'água ou para melhorar o apelo visual das suas apresentações de dados.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para o separador Notebook e aceder ao Jupyter Notebook para praticar.

click-notebook
Por vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se encontrar problemas durante a aprendizagem, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para si.

Criando um Jupyter Notebook e Importando as Bibliotecas Necessárias

Na primeira célula do seu notebook, insira o seguinte código para importar as bibliotecas necessárias:

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.cbook as cbook
import matplotlib.image as image

Vamos entender o que cada uma destas bibliotecas faz:

  • matplotlib.pyplot (apelidado como plt): Uma coleção de funções que fazem o matplotlib funcionar como o MATLAB, fornecendo uma interface conveniente para criar gráficos.
  • numpy (apelidado como np): Um pacote fundamental para computação científica em Python, que usaremos para manipulação de dados.
  • matplotlib.cbook: Uma coleção de funções utilitárias para matplotlib, incluindo funções para obter dados de exemplo.
  • matplotlib.image: Um módulo para funcionalidades relacionadas a imagens no matplotlib, que usaremos para ler e exibir imagens.

Execute a célula clicando no botão "Run" na parte superior do notebook ou pressionando Shift+Enter.

libraries-imported

A execução desta célula deve ser concluída sem qualquer saída, indicando que todas as bibliotecas foram importadas com sucesso.

Carregando e Examinando a Imagem

Agora que importamos as nossas bibliotecas, precisamos carregar a imagem que queremos sobrepor no nosso gráfico. O Matplotlib fornece algumas imagens de exemplo que podemos usar para praticar.

  1. Crie uma nova célula no seu notebook e insira o seguinte código:
## Load the sample image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Display information about the image
print(f"Image shape: {im.shape}")
print(f"Image data type: {im.dtype}")

## Display the image
plt.figure(figsize=(4, 4))
plt.imshow(im)
plt.axis('off')  ## Hide axis
plt.title('Matplotlib Logo')
plt.show()

Este código faz o seguinte:

  • Usa cbook.get_sample_data() para carregar uma imagem de exemplo chamada 'logo2.png' da coleção de dados de exemplo do Matplotlib.
  • Usa image.imread() para ler o ficheiro de imagem num array NumPy.
  • Imprime informações sobre as dimensões e o tipo de dados da imagem.
  • Cria uma figura e exibe a imagem usando plt.imshow().
  • Oculta as marcas e rótulos dos eixos com plt.axis('off').
  • Adiciona um título à figura.
  • Exibe a figura usando plt.show().
  1. Execute a célula pressionando Shift+Enter.

A saída deve exibir informações sobre a imagem e mostrar o logótipo do Matplotlib. A forma da imagem indica as dimensões da imagem (altura, largura, canais de cor), e o tipo de dados informa-nos como os dados da imagem são armazenados.

image-info

Este passo é importante porque nos ajuda a entender a imagem que usaremos como sobreposição. Podemos ver a sua aparência e dimensões, o que será útil ao decidir como posicioná-la no nosso gráfico.

Criando um Gráfico Básico com Dados Aleatórios

Antes de adicionarmos a sobreposição da nossa imagem, precisamos criar um gráfico que servirá como base para a nossa visualização. Vamos criar um gráfico de barras simples usando dados aleatórios.

  1. Crie uma nova célula no seu notebook e insira o seguinte código:
## Create a figure and axes for our plot
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)  ## x-axis values (0 to 29)
y = x + np.random.randn(30)  ## y-axis values (x plus random noise)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')  ## Green bars

## Add grid lines
ax.grid(linestyle='--', alpha=0.7)

## Add labels and title
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Random Data')

## Display the plot
plt.tight_layout()
plt.show()

Este código faz o seguinte:

  • Cria uma figura e eixos com um tamanho específico usando plt.subplots().
  • Define uma semente aleatória para garantir que obtemos os mesmos valores aleatórios cada vez que executamos o código.
  • Gera 30 valores x (0 a 29) e os correspondentes valores y (x mais ruído aleatório).
  • Cria um gráfico de barras com barras verdes usando ax.bar().
  • Adiciona linhas de grade ao gráfico com ax.grid().
  • Adiciona rótulos para o eixo x, eixo y e um título para o gráfico.
  • Usa plt.tight_layout() para ajustar o espaçamento para uma melhor aparência.
  • Exibe o gráfico usando plt.show().
  1. Execute a célula pressionando Shift+Enter.

A saída deve exibir um gráfico de barras com barras verdes representando os dados aleatórios. O eixo x mostra inteiros de 0 a 29, e o eixo y mostra os valores correspondentes com ruído aleatório adicionado.

Este gráfico será a base sobre a qual sobreporemos a nossa imagem no próximo passo. Observe como armazenamos o objeto figura na variável fig e o objeto eixos na variável ax. Precisaremos dessas variáveis para adicionar a sobreposição da nossa imagem.

Sobrepondo a Imagem no Gráfico

Agora que criamos o nosso gráfico base, vamos sobrepor a imagem nele. Usaremos o método figimage para adicionar a imagem à figura, e torná-la semi-transparente para que o gráfico por baixo permaneça visível.

  1. Crie uma nova célula no seu notebook e insira o seguinte código:
## Create a figure and axes for our plot (same as before)
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)  ## x-axis values (0 to 29)
y = x + np.random.randn(30)  ## y-axis values (x plus random noise)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')  ## Green bars

## Add grid lines
ax.grid(linestyle='--', alpha=0.7)

## Add labels and title
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Image Overlay')

## Load the image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Overlay the image on the plot
## Parameters:
## - im: the image data
## - 25, 25: x and y position in pixels from the bottom left
## - zorder=3: controls the drawing order (higher numbers are drawn on top)
## - alpha=0.5: controls the transparency (0 = transparent, 1 = opaque)
fig.figimage(im, 25, 25, zorder=3, alpha=0.5)

## Display the plot
plt.tight_layout()
plt.show()

Este código combina o que fizemos nos passos anteriores e adiciona o método figimage para sobrepor a nossa imagem no gráfico. Aqui está uma análise dos parâmetros figimage:

  • im: Os dados da imagem como um array NumPy.
  • 25, 25: As posições x e y em pixels a partir do canto inferior esquerdo da figura.
  • zorder=3: Controla a ordem de desenho. Números mais altos são desenhados em cima de elementos com números mais baixos.
  • alpha=0.5: Controla a transparência da imagem. Um valor de 0 é completamente transparente, e 1 é completamente opaco.
  1. Execute a célula pressionando Shift+Enter.

A saída deve mostrar o mesmo gráfico de barras de antes, mas agora com o logótipo do Matplotlib sobreposto no canto inferior esquerdo. O logótipo deve ser semi-transparente, permitindo que o gráfico por baixo permaneça visível.

  1. Vamos experimentar com diferentes posições e níveis de transparência. Crie uma nova célula e insira o seguinte código:
## Create a figure and axes for our plot
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)
y = x + np.random.randn(30)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Centered Image Overlay')

## Load the image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Get figure dimensions
fig_width, fig_height = fig.get_size_inches() * fig.dpi

## Calculate center position (this is approximate)
x_center = fig_width / 2 - im.shape[1] / 2
y_center = fig_height / 2 - im.shape[0] / 2

## Overlay the image at the center with higher transparency
fig.figimage(im, x_center, y_center, zorder=3, alpha=0.3)

## Display the plot
plt.tight_layout()
plt.show()

Este código coloca a imagem no centro da figura com um nível de transparência mais alto (alpha=0.3), tornando-a mais adequada como uma marca d'água.

  1. Execute a célula pressionando Shift+Enter.

A saída deve mostrar o gráfico de barras com o logótipo centrado e mais transparente do que antes, criando um efeito de marca d'água.

Criando uma Função Reutilizável para Sobreposições de Imagens

Para tornar o nosso código mais reutilizável, vamos criar uma função que pode adicionar uma sobreposição de imagem a qualquer figura do Matplotlib. Desta forma, podemos facilmente aplicar o mesmo efeito a diferentes gráficos.

  1. Crie uma nova célula no seu notebook e insira o seguinte código:
def add_image_overlay(fig, image_path, x_pos=25, y_pos=25, alpha=0.5, zorder=3):
    """
    Add an image overlay to a matplotlib figure.

    Parameters:
    -----------
    fig : matplotlib.figure.Figure
        The figure to add the image to
    image_path : str
        Path to the image file
    x_pos : int
        X position in pixels from the bottom left
    y_pos : int
        Y position in pixels from the bottom left
    alpha : float
        Transparency level (0 to 1)
    zorder : int
        Drawing order (higher numbers are drawn on top)

    Returns:
    --------
    fig : matplotlib.figure.Figure
        The figure with the image overlay
    """
    ## Load the image
    with cbook.get_sample_data(image_path) as file:
        im = image.imread(file)

    ## Add the image to the figure
    fig.figimage(im, x_pos, y_pos, zorder=zorder, alpha=alpha)

    return fig

## Example usage: Create a scatter plot with an image overlay
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data for a scatter plot
x = np.random.rand(50) * 10
y = np.random.rand(50) * 10

## Create a scatter plot
ax.scatter(x, y, s=100, c=np.random.rand(50), cmap='viridis', alpha=0.7)
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Scatter Plot with Image Overlay')

## Add the image overlay using our function
add_image_overlay(fig, 'logo2.png', x_pos=50, y_pos=50, alpha=0.4)

## Display the plot
plt.tight_layout()
plt.show()

Este código define uma função chamada add_image_overlay que:

  • Recebe parâmetros para a figura, caminho da imagem, posição, transparência e z-order.
  • Carrega a imagem especificada.
  • Adiciona a imagem à figura usando figimage.
  • Retorna a figura modificada.

Após definir a função, demonstramos seu uso criando um gráfico de dispersão com dados aleatórios e adicionando o logótipo do Matplotlib como uma sobreposição.

  1. Execute a célula pressionando Shift+Enter.

A saída deve mostrar um gráfico de dispersão com pontos posicionados e coloridos aleatoriamente, e o logótipo do Matplotlib sobreposto na posição (50, 50) com 40% de opacidade.

  1. Vamos tentar mais um exemplo com um gráfico de linhas. Crie uma nova célula e insira o seguinte código:
## Example usage: Create a line plot with an image overlay
fig, ax = plt.subplots(figsize=(10, 6))

## Generate data for a line plot
x = np.linspace(0, 10, 100)
y = np.sin(x)

## Create a line plot
ax.plot(x, y, linewidth=2, color='#d62728')
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Sine Wave with Image Overlay')
ax.set_ylim(-1.5, 1.5)

## Add the image overlay using our function
## Place it in the bottom right corner
fig_width, fig_height = fig.get_size_inches() * fig.dpi
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)
    x_pos = fig_width - im.shape[1] - 50  ## 50 pixels from the right edge

add_image_overlay(fig, 'logo2.png', x_pos=x_pos, y_pos=50, alpha=0.6)

## Display the plot
plt.tight_layout()
plt.show()

Este código cria um gráfico de linhas mostrando uma onda senoidal e adiciona o logótipo do Matplotlib no canto inferior direito do gráfico.

  1. Execute a célula pressionando Shift+Enter.

A saída deve mostrar um gráfico de linhas de uma onda senoidal com o logótipo do Matplotlib sobreposto no canto inferior direito com 60% de opacidade.

Estes exemplos demonstram como a nossa função add_image_overlay pode ser usada para adicionar facilmente sobreposições de imagem a diferentes tipos de gráficos, tornando-a uma ferramenta versátil para personalizar visualizações.

Resumo

Neste tutorial, você aprendeu como sobrepor imagens em gráficos do Matplotlib para criar marcas d'água, logótipos ou outros elementos visuais que aprimoram suas visualizações. Aqui está um resumo do que cobrimos:

  1. Importando Bibliotecas: Começamos importando as bibliotecas necessárias para trabalhar com gráficos e imagens do Matplotlib.

  2. Carregando e Examinando Imagens: Aprendemos como carregar imagens usando a função imread e como inspecionar suas propriedades.

  3. Criando Gráficos Base: Criamos diferentes tipos de gráficos (gráficos de barras, gráficos de dispersão e gráficos de linhas) para servir como base para as nossas sobreposições de imagens.

  4. Sobrepondo Imagens: Usamos o método figimage para colocar imagens em nossos gráficos, controlando sua posição, transparência e ordem de desenho.

  5. Criando uma Função Reutilizável: Desenvolvemos uma função reutilizável para facilitar a adição de sobreposições de imagem a qualquer figura do Matplotlib.

As habilidades que você aprendeu neste tutorial podem ser aplicadas a:

  • Adicionar marcas d'água a gráficos para proteção de direitos autorais
  • Incluir logótipos para branding em visualizações
  • Criar elementos de fundo personalizados para gráficos esteticamente agradáveis
  • Combinar imagens com visualizações de dados para apresentações e relatórios

Você pode continuar experimentando com diferentes tipos de gráficos, imagens, posições e níveis de transparência para criar visualizações únicas e com aparência profissional que atendam às suas necessidades específicas.