Axes is the primary place where we put plot elements, such as lines, texts and legends. However, for a long time, I failed to grasp the meaning of aspect ratio in Matplotlib, thus was constantly frustrated by the behavior of Maplotlib every time I attempted to change the aspect ratio of a plot. This post is the result of my attempt to understand it and my findings. Hope it can help you too.
A first unsuccessful try
Suppose I have the following code:
import matplotlib.pyplot as plt import numpy as np plt.style.use('ggplot') x = np.linspace(-5, 5, 100) y1 = np.exp(0.5*x) y2 = np.sin(x) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, y1) ax.plot(x, y2) plt.show()
The code snippet above produces the following image
This image is a bit thin. What if I want the width of the output image to be longer than its height, for example , an image with aspect ratio 0.6? According to the official documentation of Matplotlib, we can use
set_aspect method of
Axes class to set aspect ratio of an Axes object. This method has a parameter
aspect which can be any positive number
num. The description for
num is rather vague:
a circle will be stretched such that the height is num times the width. aspect=1 is the same as aspect='equal'.
After I add a statement
in the above script, the rendered output image becomes
Apparently, this is not what I want: the new output image is even thinner. But what has gone wrong? It took me a lot of efforts to find out.
The meaning of aspect ratio in Matplotlib
Before we get into aspect ratio, we should first know that there are four different coordinate systems in Matplotlib, which you are dealing with implicitly. Below is a brief description:
|data||The userland data coordinate system, controlled by the xlim and ylim|
|axes||The coordinate system of the Axes; (0,0) is bottom left of the axes, and (1,1) is top right of the axes.|
|figure||The coordinate system of the Figure; (0,0) is bottom left of the figure, and (1,1) is top right of the figure.|
|display||This is the pixel coordinate system of the display; (0,0) is the bottom left of the display, and (width, height) is the top right of the display in pixels.|
Usually, these coordinate systems will work under the hood and you can hardly notice their existence. In our case, what we really want to set is the aspect ratio in the display coordinate system, i.e., the physical length of axes height divided by its width. But the aspect ratio in the
set_aspect() method refers to the aspect ratio in data coordinate system. For example, if the aspect ratio equals 1, then in the display coordinate, the same length in data coordinate have the same displayed length. See the following image for an example (aspect=1):
You can easily verify that for the same interval in data coordinate system in x and y axis, they have the same length in display coordinate system.
Transform between data and display coordinate
Now that we know this distinction, the issue boils down to calculating the right aspect ratio to use in data coordinate system given the desired aspect ratio in display coordinate system. Suppose the axes height and width of the output plot are denoted as \(disp_h\) and \(disp_w\), then the desired display aspect ratio is
If we denote the height and width in the data coordinate system as \(data_h\) and \(data_w\), we have the following equation:
Then the aspect we need to use in the
set_aspect() method is
\(data_h\) and \(data_w\) in the above equation can be easily calculated once we get the x and y axis limit using
get_ylim()methods of an Axes class object. Or we can directly calculate the
dataRatio using the
get_data_ratio method of Axes class.
The final plot
Now we are ready to set the display aspect ratio to whatever value we want using the following code:
import matplotlib.pyplot as plt import numpy as np plt.style.use('ggplot') x = np.linspace(-5, 5, 100) y1 = np.exp(0.8*x) y2 = np.sin(x) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, y1) ax.plot(x, y2) ratio = 0.3 xleft, xright = ax.get_xlim() ybottom, ytop = ax.get_ylim() # the abs method is used to make sure that all numbers are positive # because x and y axis of an axes maybe inversed. ax.set_aspect(abs((xright-xleft)/(ybottom-ytop))*ratio) # or we can utilise the get_data_ratio method which is more concise # ax.set_aspect(1.0/ax.get_data_ratio()*ratio) plt.show()
The following images are plotted using the same data but with different display aspect ratios.
(red numbers in each plot denote their axes aspect ratio)
When we have shared x axis
Usually, when we plot two subplots in a 1*2 layout, they have the same x axis but different y axis limit. If we share their x axis, we must set the parameter
adjustable to "box-forced" in order to set the aspect ratios correctly. Below is a valid example showing how to do this
import matplotlib.pyplot as plt import numpy as np y1 = np.random.uniform(0.1, 0.7, size=(167,)) y2 = np.random.uniform(1, 100, size=(167,)) y1 = sorted(y1) y2 = sorted(y2) fig = plt.figure(figsize=(10,3)) fig.set_edgecolor('red') ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122, sharex=ax1) ax1.plot(y1) ax1.set_ylim([min(y1)*0.9, max(y1)*1.1]) ax1.set_ylabel('y1') ax2.plot(y2) ax2.set_ylim([min(y2)*0.9, max(y2)*1.1]) ax2.set_ylabel('y2') ratio = 0.4 for ax in [ax1, ax2]: xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() print((xmax-xmin)/(ymax-ymin)) ax.set_aspect(abs((xmax-xmin)/(ymax-ymin))*ratio, adjustable='box-forced') plt.show()
The produced figure is
The two subplots in the above figure have exactly the same display aspect ratio.
OK, this is the end of this post, I hope that now you can finally set the desired image aspect ratio without any difficulty.
License CC BY-NC-ND 4.0