Resumen de mpl_toolkits.axes_grid1

axes_grid1proporciona las siguientes características:

• Clases auxiliares ( ImageGrid , RGBAxes , AxesDivider ) para facilitar el diseño de ejes que muestran imágenes con una relación de aspecto fija mientras se satisfacen restricciones adicionales (hacer coincidir las alturas de una barra de colores y una imagen, o arreglar el relleno entre imágenes);

• ParasiteAxes (características twinx/twiny-like para que pueda trazar diferentes datos (por ejemplo, diferentes escalas y) en los mismos ejes);

• AnchoredArtists (artistas personalizados que se colocan en una posición anclada, de forma similar a las leyendas).

ejes_grid1

ImageGrid

En Matplotlib, la ubicación y el tamaño de los ejes generalmente se especifican en coordenadas de figura normalizadas (0 = abajo a la izquierda, 1 = arriba a la derecha), lo que dificulta lograr un relleno fijo (absoluto) entre las imágenes. ImageGridse puede utilizar para lograr dicho relleno; consulte sus documentos para obtener información detallada sobre la API.

• La posición de cada eje se determina en el momento del dibujo (consulte AxesDivider ), de modo que el tamaño de la cuadrícula completa se ajuste al rectángulo dado (como el aspecto de los ejes). Tenga en cuenta que en este ejemplo, los rellenos entre ejes son fijos incluso si cambia el tamaño de la figura.

• Los ejes en la misma columna comparten su eje x, y los ejes en la misma fila comparten su eje y (en el sentido de sharex, sharey). Además, los ejes en la misma columna tienen todos el mismo ancho y los ejes en la misma fila tienen la misma altura. Estos anchos y altos se escalan en proporción a los límites de vista de los ejes (xlim o ylim).

  

Los siguientes ejemplos muestran lo que puede hacer con ImageGrid.

AxesDivider Clase

Detrás de escena, ImageGrid (y RGBAxes, que se describen a continuación) se basan en AxesDivider, cuya función es calcular la ubicación de los ejes en el momento del dibujo.

Por lo general, los usuarios no necesitan instanciar divisores directamente llamando a AxesDivider; en cambio, make_axes_locatablese puede usar para crear un divisor para un Axes:

ax = subplot(1, 1, 1)
divider = make_axes_locatable(ax)

AxesDivider.append_axesluego se puede usar para crear nuevos ejes en un lado dado ("izquierda", "derecha", "arriba", "abajo") de los ejes originales.

barra de color cuya altura (o ancho) está sincronizada con los ejes principales

scatter_hist.py con AxesDivider

El ejemplo de diagrama de dispersión con histogramas se puede reescribir usando make_axes_locatable:

axScatter = plt.subplot()
axScatter.scatter(x, y)
axScatter.set_aspect(1.)

# create new axes on the right and on the top of the current axes.
divider = make_axes_locatable(axScatter)
axHistx = divider.append_axes("top", size=1.2, pad=0.1, sharex=axScatter)
axHisty = divider.append_axes("right", size=1.2, pad=0.1, sharey=axScatter)

# the scatter plot:
# histograms
bins = np.arange(-lim, lim + binwidth, binwidth)
axHistx.hist(x, bins=bins)
axHisty.hist(y, bins=bins, orientation='horizontal')

Vea el código fuente completo a continuación.

El histograma de dispersión (ejes localizables) que usa AxesDivider tiene algunas ventajas sobre el gráfico de dispersión original con histogramas en Matplotlib. Por ejemplo, puede establecer la relación de aspecto del diagrama de dispersión, incluso con el eje x o el eje y se comparte en consecuencia.

Parásitos Ejes

El ParasiteAxes es un Axe cuya ubicación es idéntica a la del host. La ubicación se ajusta en el tiempo de dibujo, por lo que funciona incluso si el host cambia su ubicación (por ejemplo, imágenes).

En la mayoría de los casos, primero crea ejes host, que proporcionan algunos métodos que se pueden usar para crear ejes parásitos. Son twinx, twiny(que son similares a twinxy twinyen matplotlib) y twin. twintoma una transformación arbitraria que mapea entre las coordenadas de datos de los ejes del host y los ejes del parásito. losdraw El método de los ejes parásitos nunca se llama. En su lugar, los ejes anfitriones reúnen a los artistas en los ejes parásitos y los dibujan como si pertenecieran a los ejes anfitriones, es decir, los artistas de los ejes parásitos se fusionan con los de los ejes anfitriones y luego se dibujan según su zorder. Los ejes huésped y parásito modifican algunos de los comportamientos de los ejes. Por ejemplo, el ciclo de color de las líneas de la trama se comparte entre el huésped y los parásitos. Además, el comando de leyenda en host crea una leyenda que incluye líneas en los ejes parásitos. Para crear un host de ejes, puede usar host_subploto host_axescomando.

Ejemplo 1. twinx

Ejemplo 2. gemelo

twinsin un argumento de transformación asume que los ejes parásitos tienen la misma transformación de datos que el host. Esto puede ser útil cuando desea que el eje superior (o derecho) tenga diferentes ubicaciones de marca, etiquetas de marca o formato de marca para el eje inferior (o izquierdo).

ax2 = ax.twin() # now, ax2 is responsible for "top" axis and "right" axis
ax2.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi],
               labels=["0", r"$\frac{1}{2}\pi$",
                       r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])

Un ejemplo más sofisticado usando twin. Tenga en cuenta que si cambia el límite x en los ejes del host, el límite x de los ejes parásitos cambiará en consecuencia.

Artistas Anclados

axes_grid1.anchored_artistses una colección de artistas cuya ubicación está anclada al (ejes) bbox, de manera similar a las leyendas. Estos artistas derivan de offsetbox.OffsetBox, y el artista debe dibujarse en coordenadas de lienzo. Hay soporte limitado para transformaciones arbitrarias. Por ejemplo, la elipse del ejemplo siguiente tendrá ancho y alto en coordenadas de datos.

InsetLocator

Ver también

Axes.inset_axesy Axes.indicate_inset_zoomen la biblioteca principal.

axes_grid1.inset_locatorproporciona clases auxiliares y funciones para colocar ejes insertados en una posición anclada de los ejes principales, de manera similar a AnchoredArtist.

inset_locator.inset_axescrea un eje insertado cuyo tamaño es fijo o una proporción fija de los ejes principales:

inset_axes = inset_axes(parent_axes,
                        width="30%",  # width = 30% of parent_bbox
                        height=1.,  # height = 1 inch
                        loc='lower left')

crea ejes insertados cuyo ancho es el 30 % de los ejes principales y cuya altura se fija en 1 pulgada.

inset_locator.zoomed_inset_axescrea un eje insertado cuya escala de datos es la de los ejes principales multiplicada por algún factor, por ejemplo

inset_axes = zoomed_inset_axes(ax,
                               0.5,  # zoom = 0.5
                               loc='upper right')

crea un eje insertado cuya escala de datos es la mitad de los ejes principales. Esto puede ser útil para marcar el área ampliada en los ejes principales:

inset_locator.mark_insetpermite marcar la ubicación del área representada por los ejes insertados:

Ejes RGB

RGBAxes es una clase de ayuda para mostrar convenientemente imágenes compuestas RGB. Al igual que ImageGrid, la ubicación de los ejes se ajusta para que el área ocupada por ellos encaje en un rectángulo determinado. Además, se comparten el eje x y el eje y de cada eje.

from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes

fig = plt.figure()
ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0)
r, g, b = get_rgb()  # r, g, b are 2D images.
ax.imshow_rgb(r, g, b)

Divisor de ejes

El mpl_toolkits.axes_grid1.axes_dividermódulo proporciona clases auxiliares para ajustar las posiciones de los ejes de un conjunto de imágenes en el momento del dibujo.

• axes_sizeproporciona una clase de unidades que se utilizan para determinar el tamaño de cada eje. Por ejemplo, puede especificar un tamaño fijo.

• Divideres la clase que calcula la posición de los ejes. Divide el área rectangular dada en varias áreas. El divisor se inicializa configurando las listas de tamaños horizontales y verticales en los que se basará la división. Luego use new_locator(), que devuelve un objeto invocable que se puede usar para establecer el axes_locator de los ejes.

Aquí, demostramos cómo lograr el siguiente diseño: queremos colocar los ejes en una cuadrícula de 3x4 (tenga en cuenta que Dividerlos índices de fila comienzan desde la parte inferior (!) de la cuadrícula):

+--------+--------+--------+--------+
| (2, 0) | (2, 1) | (2, 2) | (2, 3) |
+--------+--------+--------+--------+
| (1, 0) | (1, 1) | (1, 2) | (1, 3) |
+--------+--------+--------+--------+
| (0, 0) | (0, 1) | (0, 2) | (0, 3) |
+--------+--------+--------+--------+

tal que la fila inferior tiene una altura fija de 2 (pulgadas) y las dos filas superiores tienen una relación de altura de 2 (medio) a 3 (superior). (Por ejemplo, si la cuadrícula tiene un tamaño de 7 pulgadas, la fila inferior será de 2 pulgadas, la fila del medio también de 2 pulgadas y la fila superior de 3 pulgadas).

Estas restricciones se especifican utilizando clases del axes_sizemódulo, a saber:

from mpl_toolkits.axes_grid1.axes_size import Fixed, Scaled
vert = [Fixed(2), Scaled(2), Scaled(3)]

(De forma más general, axes_sizelas clases definen un get_size(renderer)método que devuelve un par de flotantes: un tamaño relativo y un tamaño absoluto. Fixed(2).get_size(renderer)devuelve ; devuelve ).(0, 2)Scaled(2).get_size(renderer)(2, 0)

Usamos estas restricciones para inicializar un Dividerobjeto:

rect = [0.2, 0.2, 0.6, 0.6]  # Position of the grid in the figure.
vert = [Fixed(2), Scaled(2), Scaled(3)]  # As above.
horiz = [...]  # Some other horizontal constraints.
divider = Divider(fig, rect, horiz, vert)

luego use Divider.new_locatorpara crear una AxesLocatorinstancia para una entrada de cuadrícula dada:

locator = divider.new_locator(nx=0, ny=1)  # Grid entry (1, 0).

y que se encargue de ubicar los ejes:

ax.set_axes_locator(locator)

es un objeto invocable que devuelve la AxesLocatorubicación y el tamaño de la celda en la primera columna y la segunda fila.

Se pueden crear localizadores que abarquen varias celdas, por ejemplo:

# Columns #0 and #1 ("0-2 range"), row #1.
locator = divider.new_locator(nx=0, nx1=2, ny=1)

Ver el ejemplo,

También puede ajustar el tamaño de cada eje de acuerdo con sus límites de datos x o y (AxesX y AxesY).