Matplotlib 2 subparcelas, 1 barra de cores

Passei muito tempo pesquisando como obter duas subparcelas para compartilhar o mesmo eixo y com uma única barra de cores compartilhada entre as duas no Matplotlib.

O que estava acontecendo era que, quando eu chamei a colorbar()função em um subplot1ou outro subplot2, ele dimensionaria automaticamente a plotagem de forma que a barra de cores mais a plotagem caíssem dentro da caixa delimitadora da 'subtrama', fazendo com que as duas plotagens lado a lado fossem duas muito diferentes. tamanhos.

Para contornar isso, tentei criar uma terceira subtrama que eu hackeei para renderizar nenhuma plotagem com apenas uma barra de cores presente. O único problema é que agora as alturas e larguras das duas parcelas são desiguais, e não consigo descobrir como fazê-la parecer correta.

Aqui está o meu código:

from __future__ import division
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import patches
from matplotlib.ticker import NullFormatter

# SIS Functions
TE = 1 # Einstein radius
g1 = lambda x,y: (TE/2) * (y**2-x**2)/((x**2+y**2)**(3/2)) 
g2 = lambda x,y: -1*TE*x*y / ((x**2+y**2)**(3/2))
kappa = lambda x,y: TE / (2*np.sqrt(x**2+y**2))

coords = np.linspace(-2,2,400)
X,Y = np.meshgrid(coords,coords)
g1out = g1(X,Y)
g2out = g2(X,Y)
kappaout = kappa(X,Y)
for i in range(len(coords)):
    for j in range(len(coords)):
        if np.sqrt(coords[i]**2+coords[j]**2) <= TE:
            g1out[i][j]=0
            g2out[i][j]=0

fig = plt.figure()
fig.subplots_adjust(wspace=0,hspace=0)

# subplot number 1
ax1 = fig.add_subplot(1,2,1,aspect='equal',xlim=[-2,2],ylim=[-2,2])
plt.title(r"$\gamma_{1}$",fontsize="18")
plt.xlabel(r"x ($\theta_{E}$)",fontsize="15")
plt.ylabel(r"y ($\theta_{E}$)",rotation='horizontal',fontsize="15")
plt.xticks([-2.0,-1.5,-1.0,-0.5,0,0.5,1.0,1.5])
plt.xticks([-2.0,-1.5,-1.0,-0.5,0,0.5,1.0,1.5])
plt.imshow(g1out,extent=(-2,2,-2,2))
plt.axhline(y=0,linewidth=2,color='k',linestyle="--")
plt.axvline(x=0,linewidth=2,color='k',linestyle="--")
e1 = patches.Ellipse((0,0),2,2,color='white')
ax1.add_patch(e1)

# subplot number 2
ax2 = fig.add_subplot(1,2,2,sharey=ax1,xlim=[-2,2],ylim=[-2,2])
plt.title(r"$\gamma_{2}$",fontsize="18")
plt.xlabel(r"x ($\theta_{E}$)",fontsize="15")
ax2.yaxis.set_major_formatter( NullFormatter() )
plt.axhline(y=0,linewidth=2,color='k',linestyle="--")
plt.axvline(x=0,linewidth=2,color='k',linestyle="--")
plt.imshow(g2out,extent=(-2,2,-2,2))
e2 = patches.Ellipse((0,0),2,2,color='white')
ax2.add_patch(e2)

# subplot for colorbar
ax3 = fig.add_subplot(1,1,1)
ax3.axis('off')
cbar = plt.colorbar(ax=ax2)

plt.show()

Basta colocar a barra de cores em seu próprio eixo e usar subplots_adjustpara abrir espaço para ela.

Como um exemplo rápido:

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.subplots_adjust(right=0.8)
cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
fig.colorbar(im, cax=cbar_ax)

plt.show()

Observe que o intervalo de cores será definido pela última imagem plotada (que deu origem im), mesmo que o intervalo de valores seja definido por vmine vmax. Se outro gráfico tiver, por exemplo, um valor máximo mais alto, os pontos com valores mais altos que o máximo de imserão exibidos em cores uniformes.

Você pode simplificar o código de Joe Kington usando o axparâmetro de figure.colorbar()com uma lista de eixos. A partir da documentação :

machado

Nenhuma objeto (s) de eixos pai dos quais o espaço para um novo eixo da barra de cores será roubado. Se uma lista de eixos for fornecida, todos serão redimensionados para dar espaço aos eixos da barra de cores.

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.ravel().tolist())

plt.show()

Esta solução não requer ajustes manuais dos locais dos eixos ou do tamanho da barra de cores, trabalha com layouts de várias linhas e de uma linha e trabalha com tight_layout(). É adaptado de um exemplo da galeria , usando ImageGrida caixa de ferramentas AxesGrid do matplotlib .

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid

# Set up figure and image grid
fig = plt.figure(figsize=(9.75, 3))

grid = ImageGrid(fig, 111,          # as in plt.subplot(111)
                 nrows_ncols=(1,3),
                 axes_pad=0.15,
                 share_all=True,
                 cbar_location="right",
                 cbar_mode="single",
                 cbar_size="7%",
                 cbar_pad=0.15,
                 )

# Add data to image grid
for ax in grid:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

# Colorbar
ax.cax.colorbar(im)
ax.cax.toggle_label(True)

#plt.tight_layout()    # Works, but may still require rect paramater to keep colorbar labels visible
plt.show()

O uso make_axesé ainda mais fácil e oferece um resultado melhor. Também oferece possibilidades de personalizar o posicionamento da barra de cores. Observe também a opção de subplotscompartilhar os eixos x e y.

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

fig, axes = plt.subplots(nrows=2, ncols=2, sharex=True, sharey=True)
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

cax,kw = mpl.colorbar.make_axes([ax for ax in axes.flat])
plt.colorbar(im, cax=cax, **kw)

plt.show()

Como iniciante que tropeçou nesse tópico, eu gostaria de adicionar uma adaptação python-por-manequins da resposta muito legal de abevieiramota (porque estou no nível em que precisei procurar 'ravel' para descobrir o que o código deles estava funcionando):

import numpy as np
import matplotlib.pyplot as plt

fig, ((ax1,ax2,ax3),(ax4,ax5,ax6)) = plt.subplots(2,3)

axlist = [ax1,ax2,ax3,ax4,ax5,ax6]

first = ax1.imshow(np.random.random((10,10)), vmin=0, vmax=1)
third = ax3.imshow(np.random.random((12,12)), vmin=0, vmax=1)

fig.colorbar(first, ax=axlist)

plt.show()

Muito menos pitônico, muito mais fácil para noobs como eu ver o que realmente está acontecendo aqui.

Como apontado em outras respostas, a idéia é geralmente definir um eixo para a barra de cores residir. Existem várias maneiras de fazer isso; um que ainda não tenha sido mencionado seria especificar diretamente os eixos da barra de cores na criação da subtrama plt.subplots(). A vantagem é que a posição dos eixos não precisa ser definida manualmente e, em todos os casos com aspecto automático, a barra de cores terá exatamente a mesma altura das subparcelas. Mesmo em muitos casos em que as imagens são usadas, o resultado será satisfatório, como mostrado abaixo.

Ao usar plt.subplots(), o uso do gridspec_kwargumento permite tornar os eixos da barra de cores muito menores que os outros eixos.

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(5.5,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})

Exemplo:

import matplotlib.pyplot as plt
import numpy as np; np.random.seed(1)

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(5.5,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})
fig.subplots_adjust(wspace=0.3)
im  = ax.imshow(np.random.rand(11,8), vmin=0, vmax=1)
im2 = ax2.imshow(np.random.rand(11,8), vmin=0, vmax=1)
ax.set_ylabel("y label")

fig.colorbar(im, cax=cax)

plt.show()

Isso funciona bem, se o aspecto das plotagens for escalonado automaticamente ou as imagens forem reduzidas devido ao aspecto na direção da largura (como acima). Se, no entanto, as imagens forem mais amplas que altas, o resultado seria o seguinte, o que pode ser indesejável.

Uma solução para fixar a altura da barra de cores à altura da subparcela seria usar mpl_toolkits.axes_grid1.inset_locator.InsetPositionpara definir os eixos da barra de cores em relação aos eixos da subparcela da imagem.

import matplotlib.pyplot as plt
import numpy as np; np.random.seed(1)
from mpl_toolkits.axes_grid1.inset_locator import InsetPosition

fig, (ax, ax2, cax) = plt.subplots(ncols=3,figsize=(7,3), 
                  gridspec_kw={"width_ratios":[1,1, 0.05]})
fig.subplots_adjust(wspace=0.3)
im  = ax.imshow(np.random.rand(11,16), vmin=0, vmax=1)
im2 = ax2.imshow(np.random.rand(11,16), vmin=0, vmax=1)
ax.set_ylabel("y label")

ip = InsetPosition(ax2, [1.05,0,0.05,1]) 
cax.set_axes_locator(ip)

fig.colorbar(im, cax=cax, ax=[ax,ax2])

plt.show()

A solução de usar uma lista de eixos por abevieiramota funciona muito bem até você usar apenas uma linha de imagens, conforme indicado nos comentários. Usando uma proporção razoável para obter figsizeajuda, mas ainda está longe de ser perfeito. Por exemplo:

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9.75, 3))
for ax in axes.flat:
    im = ax.imshow(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.ravel().tolist())

plt.show()

A função barra de cores fornece o shrinkparâmetro que é um fator de escala para o tamanho dos eixos da barra de cores. Requer alguma tentativa e erro manual. Por exemplo:

fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.75)

Para adicionar à excelente resposta de @ abevieiramota, você pode obter o euqivalente de tight_layout com constrained_layout. Você ainda terá grandes espaços horizontais se usar em imshowvez da pcolormeshrazão de aspecto de 1: 1 imposta por imshow.

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=2, ncols=2, constrained_layout=True)
for ax in axes.flat:
    im = ax.pcolormesh(np.random.random((10,10)), vmin=0, vmax=1)

fig.colorbar(im, ax=axes.flat)
plt.show()

Percebi que quase todas as soluções postadas envolviam ax.imshow(im, ...)e não normalizavam as cores exibidas na barra de cores para as várias sub-configurações. O immapeável é extraído da última instância, mas e se os valores dos múltiplos im-s forem diferentes? (Suponho que esses mapas mapeáveis ​​sejam tratados da mesma maneira que os conjuntos de contorno e superfície). Eu tenho um exemplo usando um gráfico de superfície 3d abaixo que cria duas barras de cores para uma subparte 2x2 (uma barra de cores por uma linha) ) Embora a pergunta solicite explicitamente um arranjo diferente, acho que o exemplo ajuda a esclarecer algumas coisas. plt.subplots(...)Infelizmente, ainda não encontrei uma maneira de fazer isso usando os eixos 3D.

Se eu pudesse posicionar as barras de cores de uma maneira melhor ... (Provavelmente existe uma maneira muito melhor de fazer isso, mas pelo menos não deve ser muito difícil de seguir.)

import matplotlib
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

cmap = 'plasma'
ncontours = 5

def get_data(row, col):
    """ get X, Y, Z, and plot number of subplot
        Z > 0 for top row, Z < 0 for bottom row """
    if row == 0:
        x = np.linspace(1, 10, 10, dtype=int)
        X, Y = np.meshgrid(x, x)
        Z = np.sqrt(X**2 + Y**2)
        if col == 0:
            pnum = 1
        else:
            pnum = 2
    elif row == 1:
        x = np.linspace(1, 10, 10, dtype=int)
        X, Y = np.meshgrid(x, x)
        Z = -np.sqrt(X**2 + Y**2)
        if col == 0:
            pnum = 3
        else:
            pnum = 4
    print("\nPNUM: {}, Zmin = {}, Zmax = {}\n".format(pnum, np.min(Z), np.max(Z)))
    return X, Y, Z, pnum

fig = plt.figure()
nrows, ncols = 2, 2
zz = []
axes = []
for row in range(nrows):
    for col in range(ncols):
        X, Y, Z, pnum = get_data(row, col)
        ax = fig.add_subplot(nrows, ncols, pnum, projection='3d')
        ax.set_title('row = {}, col = {}'.format(row, col))
        fhandle = ax.plot_surface(X, Y, Z, cmap=cmap)
        zz.append(Z)
        axes.append(ax)

## get full range of Z data as flat list for top and bottom rows
zz_top = zz[0].reshape(-1).tolist() + zz[1].reshape(-1).tolist()
zz_btm = zz[2].reshape(-1).tolist() + zz[3].reshape(-1).tolist()
## get top and bottom axes
ax_top = [axes[0], axes[1]]
ax_btm = [axes[2], axes[3]]
## normalize colors to minimum and maximum values of dataset
norm_top = matplotlib.colors.Normalize(vmin=min(zz_top), vmax=max(zz_top))
norm_btm = matplotlib.colors.Normalize(vmin=min(zz_btm), vmax=max(zz_btm))
cmap = cm.get_cmap(cmap, ncontours) # number of colors on colorbar
mtop = cm.ScalarMappable(cmap=cmap, norm=norm_top)
mbtm = cm.ScalarMappable(cmap=cmap, norm=norm_btm)
for m in (mtop, mbtm):
    m.set_array([])

# ## create cax to draw colorbar in
# cax_top = fig.add_axes([0.9, 0.55, 0.05, 0.4])
# cax_btm = fig.add_axes([0.9, 0.05, 0.05, 0.4])
cbar_top = fig.colorbar(mtop, ax=ax_top, orientation='vertical', shrink=0.75, pad=0.2) #, cax=cax_top)
cbar_top.set_ticks(np.linspace(min(zz_top), max(zz_top), ncontours))
cbar_btm = fig.colorbar(mbtm, ax=ax_btm, orientation='vertical', shrink=0.75, pad=0.2) #, cax=cax_btm)
cbar_btm.set_ticks(np.linspace(min(zz_btm), max(zz_btm), ncontours))

plt.show()
plt.close(fig)
## orientation of colorbar = 'horizontal' if done by column

Este tópico é bem abordado, mas eu ainda gostaria de propor outra abordagem em uma filosofia um pouco diferente.

É um pouco mais complexo de configurar, mas permite (na minha opinião) um pouco mais de flexibilidade. Por exemplo, pode-se jogar com as respectivas proporções de cada subparcela / barra de cores:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.gridspec import GridSpec

# Define number of rows and columns you want in your figure
nrow = 2
ncol = 3

# Make a new figure
fig = plt.figure(constrained_layout=True)

# Design your figure properties
widths = [3,4,5,1]
gs = GridSpec(nrow, ncol + 1, figure=fig, width_ratios=widths)

# Fill your figure with desired plots
axes = []
for i in range(nrow):
    for j in range(ncol):
        axes.append(fig.add_subplot(gs[i, j]))
        im = axes[-1].pcolormesh(np.random.random((10,10)))

# Shared colorbar    
axes.append(fig.add_subplot(gs[:, ncol]))
fig.colorbar(im, cax=axes[-1])

plt.show()