get aspect ratio of axes

Question

Is there an easy and reliable way to determine the current aspect ratio of an axes when its aspect is set to 'auto'?

The obvious thing to check is ax.get_aspect(), but that just returns 'auto'. I can set it to an arbitrary constant value by ax.set_aspect(aspect), after which that same constant is returned by ax.get_aspect(). By default (and very usefully) we have aspect = 'auto', in which case the aspect ratio is automatically calculated and adjusted to match the data limits and axes size.
How can I get the numeric aspect ratio that was automatically selected?

To clarify, this is neither the aspect ratio of the data limits returned by ax.get_data_ratio(), nor the aspect ratio of the display size of the figure or subplot returned by fig.get_figheight() / fig.get_figwidth() (for the figure). It's a bit subtle, as it depends on both the display size and the data limits. (Which can lead to confusing the different ratios and the reason I find it important to have it easily accessible.)

Based on your comment to @Frank's answer, I am going to guess display or something more complex. — Mad Physicist, Feb 02 '17 at 22:13
It's "something more complex," unfortunately, @MadPhysicist. See my edited question. — askewchan, Feb 02 '17 at 22:45
Sorry that yesterday I was too tired to realize that my solution just works in case of aspect='equal', but your are asking for the other cases. Since there doesn't seem to be a simple method for getting this, I have requested this feature: https://github.com/matplotlib/matplotlib/issues/8013 — Frank Breitling, Feb 03 '17 at 10:11
Hi @tacaswell, I used it to calculate the `rotation` angle for `ax.annotate`. Being able to set the *slope* of text (in data units) would solve the same problem for my case. — askewchan, Feb 09 '17 at 19:19
Have a look at the contour labeling code which does something similar, but I am not sure exactly how it does it under the hood. — tacaswell, Feb 09 '17 at 20:01
@tacaswell I actually ran across that, there is a subclass of `Text`, but I could not find an easy way to use it. I'll look deeper. — askewchan, Feb 09 '17 at 20:04

score 17 · Answer 1 · answered Feb 02 '17 at 23:10

From the docs, the aspect ratio is the ratio of data-to-display scaling units in the x- and y-axes. i.e., if there are 10 data units per display in the y-direction and 1 data unit per display unit in the x-direction, the ratio would be 1/10. The circle would be 10 times wider than it is tall. This corresponds to the statement that an aspect of num does the following:

a circle will be stretched such that the height is num times the width. aspect=1 is the same as aspect=’equal’.

Based on the same original piece of code that you looked at (matplotlib.axes._base.adjust_aspect, starting around line 1405), I think we can come up with a simplified formula as long as you only need this ratio for linear Cartesian axes. Things get complicated with polar and logarithmic axes, so I will ignore them.

To reiterate the formula:

(x_data_unit / x_display_unit) / (y_data_unit / y_display_unit)

This happens to be the same as

(y_display_unit / x_display_unit) / (y_data_unit / x_data_unit)

This last formulation is just the ratio of the display sizes in the two directions divided by the ratio of the x and y limits. Note that ax.get_data_ratio does NOT apply here because that returns the results for the actual data bounds, not the axis limits at all:

from operator import sub
def get_aspect(ax):
    # Total figure size
    figW, figH = ax.get_figure().get_size_inches()
    # Axis size on figure
    _, _, w, h = ax.get_position().bounds
    # Ratio of display units
    disp_ratio = (figH * h) / (figW * w)
    # Ratio of data units
    # Negative over negative because of the order of subtraction
    data_ratio = sub(*ax.get_ylim()) / sub(*ax.get_xlim())

    return disp_ratio / data_ratio

Now let's test it:

from matplotlib import pyplot as plt
fig, ax = plt.subplots()
ax.set_aspect('equal')
print('{} == {}'.format(ax.get_aspect(), get_aspect(ax)))
ax.set_aspect(10)
print('{} == {}'.format(ax.get_aspect(), get_aspect(ax)))

This works. I am surprised there is no easier way to do that. I wonder why `matplotlib` does not provide `get_aspect` function. — Pygmalion, Feb 29 '20 at 18:12
@MadPhysicist You need that value every time you want to draw a circle. I don't know if it's that niche. — Guimoute, Jun 17 '20 at 21:55
@Guimoute. This is getting the aspect ratio. You just need `set_aspect('equal')` to draw a circle. So I'd say my comment aged reasonably well. — Mad Physicist, Jun 17 '20 at 22:50
Yes but `set_aspect("equal")` is not a universal solution. In many cases you might want to work on circles in an already existing canvas with a given and constant aspect ratio. For example, I stumbled upon here because I'm writing a function to get the closest data point to my cursor, and of course I did not anticipate that `sqrt(dx² + dy²)` is not an acceptable definition of distance because of the changing data limits and figure ratios. I'm looking at a circle in display units which is an ellipsis in data units. **Edit:** so your solution is perfect for that and `dx /= get_aspect(ax)` works. — Guimoute, Jun 17 '20 at 23:10

score 4 · Answer 2 · answered Jan 11 '17 at 17:32

4

The best thing I can find is this:

def get_aspect(ax=None):
    if ax is None:
        ax = plt.gca()
    fig = ax.figure

    ll, ur = ax.get_position() * fig.get_size_inches()
    width, height = ur - ll
    axes_ratio = height / width
    aspect = axes_ratio / ax.get_data_ratio()

    return aspect

But it's surprisingly complicated, and I'm not sure if it is reliable under transforms, etc, as I know nothing about the bbox and transform objects.

answered Jan 11 '17 at 17:32

askewchan

45,161
17
118
134

1

I feel like you should add this to your question and ask if there is a easier or more reliable way than this – depperm Jan 11 '17 at 17:34
This code looks approximately like the code in `Axes.apply_aspect` in matplotlib itself. – Mad Physicist Feb 02 '17 at 22:26

score 2 · Answer 3 · answered Feb 02 '17 at 22:07

2

How about

import numpy as np
aspect = sum(np.abs(ax.get_xlim())) / sum(np.abs(ax.get_ylim()))

answered Feb 02 '17 at 22:07

Frank Breitling

942
1
10
27

Thanks, @Frank, but I believe that just gives `1/ax.get_data_ratio()`. – askewchan Feb 02 '17 at 22:12
Oh that's right and even better than my suggestion. I didn't know this existed. I thought that's what your are looking for but apparently its something else. Sorry. – Frank Breitling Feb 02 '17 at 22:34
why `np.abs()` ? This won't work if both limits have the same sign. – Jason S Apr 22 '19 at 21:40

score 0 · Answer 4 · answered Aug 21 '20 at 00:02

0

I am not sure if it does exactly what you want, but try it

    bbox = axis.get_window_extent().transformed(figure.dpi_scale_trans.inverted())
    aspect_ratio = bbox.width / bbox.height

answered Aug 21 '20 at 00:02

Vladyslav Savchenko

1,282
13
10

get aspect ratio of axes

4 Answers4

Linked