Strange behaviour when saving with constrained_layout and set_aspect('equal')

[ArchangeGabriel]

Bug report

Bug summary

When saving a figure with equal aspect while using constrained_layout, the output changes when iterating saves. The issue is not present with tight_layout instead. It also seems that the figure must be close to both borders for that issue to arise.

Code for reproduction

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(6.4,6.4),constrained_layout=True)
fig.set_constrained_layout_pads(w_pad=0, h_pad=0)
ax = fig.add_subplot(111)
ax.set_aspect('equal')
plt.savefig('test.pdf')
plt.savefig('test2.pdf')
plt.savefig('test3.pdf')
plt.savefig('test4.pdf')
plt.savefig('test5.pdf')

Actual outcome

test.pdf
test2.pdf
test3.pdf
test4.pdf
test5.pdf

All outputs differ excepted for 4 and 5. The number of iterations required to reach convergence depends on the actual content of the figure (in another test, only 3 were required).

Expected outcome

All outputs should be identical. And from the above series and my other test mentionned, I would say the first one is the correct one here, but maybe not necessarily in more complex cases apparently (I’m currently toying with resizing the figure when using aspect equal to remove white space around and I’m getting strange results, I will probably post about this on the ML soon).

Matplotlib version

• Operating system: Arch Linux
• Matplotlib version: 2.2.2
• Matplotlib backend (print(matplotlib.get_backend())): Qt5Agg
• Python version: 3.6.6

[jklymak]

Are you able to check master. 98% sure that’s fixed.

[ArchangeGabriel]

OK, I’ll definitively need to setup a way to test master then. Will keep you updated.

[jklymak]

I confirm that this is a bug, but I expect its pretty hard to squash. If a problem drifts into the poorly constrained space, then the linear solver finds a solution, but it need not be unique. As you run the solver more times it iterates down into a stable solution. If you require unique solutions best not to use constrained_layout, at least for your final render; its not a deterministic algorithm like tight_layout.

[ArchangeGabriel]

Well, thing is tight_layout gives not really good results in #7806 (especially #7806 (comment) vs #7806 (comment)). I thought that you would prefer to fix constrained_layout rather than tight_layout (given the 2.2 release notes saying that the former might replace the later at some point), that’s why I did not insist on tight_layout.

I’m wondering however on the uniqueness of the solution. I don’t know the details of your algorithm, but as far as I understand things based on my simple case there is an unique solution for the perfect layout within a given space. For instance here, I think that tick font size is fixed, tick separation from the spine too, so that you can now compute the remaining space in both direction, keep the smaller one to draw the figure, and then put half the difference on both sides of the figure in the longer direction.

If I don’t constrain the figure size so that the remaining space in both direction is (almost or exactly) identical, it seems to do this job pretty well. So what gets wrong when restraining the space?

[ArchangeGabriel]

I’ve tried master, convergence is reached at the second one instead of 4, but rendering matches 4 and 5 (so same convergence achieved). However the first rendering has changed too, and is more wrong than the previous one.
test_new.pdf

I’ll move on and continue my tests with both tight and constrained, I’ll start by checking if tight got any better in master w.r.t. surrounding white space.

[ArchangeGabriel]

tight_layout is not deterministic either, I’ve found a case were iterating it change the results until convergence is reached to the numerical precision of ~1e-16. I’ll post a detailed story a bit later, still investigating.

[ArchangeGabriel]

OK, here is a small example while I keep investigating my issue:

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_aspect('equal')
plt.tight_layout(pad=0)
bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1])
for i in range(100):
    plt.tight_layout(pad=0)
    bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
    print("%.16e"%bbox[0,0],bbox[1,0])

The positioning “error” is basically halved until -2.8421709430404008e-16 is reached, after what it iterates between 3 values (so not even really converged).

[ArchangeGabriel]

So here is my summary.

What I’m actually trying to do: set_aspect('equal') figures without whitespace on the edges while keeping the size fixed to a given value on either height or width (in the spirit of #7806). My idea for that is to:

1. Create a figure with the required size on the given dimension, and a large number on the other. For instance, say I want a 8 inches wide figure, I’ll start with fig = plt.figure(figsize=(8,20)).
2. Do my plot.
3. Adjust it with either tight_layout or constrained_layout (btw, first issue here, I did not found how to force constrained_layout to apply excepted by saving the figure).
4. Get the occupied size with bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points().
5. Set the figure size accordingly fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1]). Note that on the required dimension (width in my example), the bbox should normally already be right, which appears to be the case in my simple tests.
6. Save my figure at that point, because I expect the frame to be correctly positioned w.r.t. the content. That’s where troubles happen.

At point 6, I don’t get the expected framing, as fig.get_tightbbox(fig.canvas.get_renderer()).get_points() shows. Now, they are two cases:

• tight_layout, where iterating calls results in something close to what I want but still have some unneeded whitespace. But given Increased padding using tight_layout with pad=0 #7806 remaining bits, that’s not really bad. However, the fact I have to iterate calls is strange and bad. I would understand one call, but not 50.
• constrained_layout, where the situation is a bit strange. Again, I have to iterate on save here since I did not found how to force computation of the layout. They are excessively strange results (calling again the same loop results in re-iterating from a fixed point, see below), and there is still surrounding whitespace at the end.

The strange constrained_layout results:

In [1]: import matplotlib.pyplot as plt
   ...: fig = plt.figure(constrained_layout=True)
   ...: fig.set_constrained_layout_pads(w_pad=0, h_pad=0)
   ...: ax = fig.add_subplot(111)
   ...: ax.set_aspect('equal')
   ...: plt.savefig('test.pdf')
   ...: bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...: fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1])
   ...: for i in range(10):
   ...:     plt.savefig('test.pdf')
   ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...:     print("%.16e"%bbox[0,0],bbox[1,0])
   ...:     
-5.4318576388888576e-03 4.941234809027778
-7.8870985243028723e-04 4.945877956814236
-4.9851311577678347e-04 4.9461681535508895
-4.8037581973602532e-04 4.9461862908469305
-4.7924223873361410e-04 4.946187424427933
-4.7917138992085978e-04 4.946187495276746
-4.7916696186987910e-04 4.946187499704797
-4.7916668511689410e-04 4.94618749998155
-4.7916666781963125e-04 4.946187499998848
-4.7916666673856415e-04 4.946187499999929

In [2]: for i in range(10):
   ...:     plt.savefig('test.pdf')
   ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...:     print("%.16e"%bbox[0,0],bbox[1,0])
   ...:     
-4.5670572916738669e-04 4.946209960937499
-4.7776285807278406e-04 4.946188903808594
-4.7907892862970891e-04 4.946187587738037
-4.7916118303916735e-04 4.9461875054836275
-4.7916632394001609e-04 4.9461875003427265
-4.7916664524597275e-04 4.946187500021421
-4.7916666532799468e-04 4.946187500001339
-4.7916666658290790e-04 4.946187500000085
-4.7916666666111498e-04 4.946187500000006
-4.7916666666637298e-04 4.9461875

In [3]: for i in range(10):
   ...:     plt.savefig('test.pdf')
   ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...:     print("%.16e"%bbox[0,0],bbox[1,0])
   ...:     
-4.5670572916686563e-04 4.9462099609375
-4.7776285807306829e-04 4.9461889038085936
-4.7907892862942468e-04 4.946187587738037
-4.7916118303916735e-04 4.9461875054836275
-4.7916632394001609e-04 4.9461875003427265
-4.7916664524597275e-04 4.946187500021421
-4.7916666532799468e-04 4.946187500001339
-4.7916666658290790e-04 4.946187500000085
-4.7916666666111498e-04 4.946187500000006
-4.7916666666637298e-04 4.9461875

In [4]: for i in range(15):
   ...:     plt.savefig('test.pdf')
   ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...:     print("%.16e"%bbox[0,0],bbox[1,0])
   ...:     
-4.5670572916686563e-04 4.9462099609375
-4.7776285807306829e-04 4.9461889038085936
-4.7907892862942468e-04 4.946187587738037
-4.7916118303916735e-04 4.9461875054836275
-4.7916632394001609e-04 4.9461875003427265
-4.7916664524597275e-04 4.946187500021421
-4.7916666532799468e-04 4.946187500001339
-4.7916666658290790e-04 4.946187500000085
-4.7916666666111498e-04 4.946187500000006
-4.7916666666637298e-04 4.9461875
-4.7916666666637298e-04 4.9461875
-4.7916666666665721e-04 4.9461875
-4.7916666666637298e-04 4.9461875
-4.7916666666665721e-04 4.9461875
-4.7916666666637298e-04 4.9461875

In [5]: for i in range(15):
   ...:     plt.savefig('test.pdf')
   ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
   ...:     print("%.16e"%bbox[0,0],bbox[1,0])
   ...:     
-4.5670572916658146e-04 4.9462099609375
-4.7776285807306829e-04 4.9461889038085936
-4.7907892862942468e-04 4.946187587738037
-4.7916118303916735e-04 4.9461875054836275
-4.7916632394001609e-04 4.9461875003427265
-4.7916664524597275e-04 4.946187500021421
-4.7916666532799468e-04 4.946187500001339
-4.7916666658290790e-04 4.946187500000085
-4.7916666666111498e-04 4.946187500000006
-4.7916666666637298e-04 4.9461875
-4.7916666666637298e-04 4.9461875
-4.7916666666665721e-04 4.9461875
-4.7916666666637298e-04 4.9461875
-4.7916666666665721e-04 4.9461875
-4.7916666666637298e-04 4.9461875

As you can see, after the first round of iteration, each subsequent round restarts from some given arbitrary value. In one long enough loop, some kind of convergence is reached, but not close from the expected value (i.e. I would expect 0, and no surrounding white space for the produced figure).

[jklymak]

Again, I have to iterate on save here since I did not found how to force computation of the layout.

You can call fig.canvas.draw() to force the layout. Sorry about that, I think its fixed 3.0.0, or 3.0.1 (not sure which).

Iteratively calling constrained_layout or tight_layout will take a few iterations for the positions to stabilize. Thats expected behaviour. If it bothers you, there is no need to use those tools because you should be able to manually place objects with any desired precision.

[ArchangeGabriel]

@jklymak Thanks for that command. :) Also, it gives different and very interesting results:

import matplotlib.pyplot as plt 
fig = plt.figure(constrained_layout=True)
fig.set_constrained_layout_pads(w_pad=0, h_pad=0)
ax = fig.add_subplot(111)
ax.set_aspect('equal')
fig.canvas.draw()
bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1])
for i in range(30):
    fig.canvas.draw()
    bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
    print("%.16e"%bbox[0,0],bbox[1,0])

In [1]: import matplotlib.pyplot as plt 
    ...: fig = plt.figure(constrained_layout=True)
    ...: fig.set_constrained_layout_pads(w_pad=0, h_pad=0)
    ...: ax = fig.add_subplot(111)
    ...: ax.set_aspect('equal')
    ...: fig.canvas.draw()
    ...: bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
    ...: fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1])
    ...: for i in range(30):
    ...:     fig.canvas.draw()
    ...:     bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
    ...:     print("%.16e"%bbox[0,0],bbox[1,0])
    ...: 
    ...:     
-1.9930555555555691e-02 4.926736111111112
-4.9826388888888577e-03 4.94168402777778
-1.2456597222217170e-03 4.945421006944446
-3.1141493055576085e-04 4.9463552517361125
-7.7853732638952057e-05 4.94658881293403
-1.9463433159122211e-05 4.946647203233509
-4.8658582898042375e-06 4.946661800808379
-1.2164645725931678e-06 4.946665450202095
-3.0411614308908006e-07 4.946666362550525
-7.6029035938063320e-08 4.946666590637633
-1.9007259102939619e-08 4.946666647659409
-4.7518146573111159e-09 4.946666661914853
-1.1879536051158843e-09 4.946666665478714
-2.9698843680610785e-10 4.94666666636968
-7.4247263152453050e-11 4.946666666592421
-1.8561886842386837e-11 4.946666666648106
-4.6403651291863453e-12 4.946666666662027
-1.1602215484648091e-12 4.946666666665507
-2.8999617522155555e-13 4.9466666666663786
-7.2570098078964909e-14 4.946666666666596
-1.8142524519741227e-14 4.94666666666665
-4.4053649617126211e-15 4.946666666666664
-1.1368683772161603e-15 4.946666666666667
-3.3158661002138010e-16 4.946666666666668
-4.7369515717340015e-17 4.946666666666668
-4.7369515717340015e-17 4.946666666666668
-4.7369515717340015e-17 4.946666666666668
-4.7369515717340015e-17 4.946666666666668
-4.7369515717340015e-17 4.946666666666668
-4.7369515717340015e-17 4.946666666666668

This seems to reach some real convergence here, and way different from the one above. It looks like what happens on savefig (pdf here in case that matters) is quite different. And saving after that still has some whitespace, but also resets the bbox to less correct values.

Now regarding the need for iterations, I’m not sure to understand you. What are the limitations in both involved algorithms that make subsequent calls change the situation? I would have thought that once you had found the solution, it would the unique optimal one. But apparently that does not happen. Maybe because my examples are too simple and the layout codes are dealing with more complicated things that do not allow them to find the solution in this simple case?

And yes I can put things by hand on my figures, but that is way too much time involved. Ideally, tight_layout or constrained_layout should get me the perfect results quite rapidly. The perfect result is: a figure that respect the given constraints (width+height, or one of them + equal aspect), has fonts and text size as specified, has the amount of padding around the global bbox as specified (0 being a possibility) and maximise the plotting area given all those. And this should be as easy as giving the instructions to plot the different elements with a syntax as simple as possible (think as in natural language). Of course this does not work like that, and I can live with some moderately complicated syntax, as long as it is “automated”/always the same (e.g. my set_size procedure).

Note that I’m very grateful of your work and the one of the other matplotlib devs, all this is just me, a perfection obsessed person, making hopeful wishes. ;)

[jklymak]

Constrained layout and tight layout never care about your set_aspect(True) call except so far as it changes the extent of the the axes tightbbox. When you shrink your figure its almost 1:1 and you end up bouncing between applying CL to expand the axes in the vertical and horizontal, and it only slowly converges.

I'd suggest not applying CL after the first draw...

import matplotlib.pyplot as plt 
fig = plt.figure(constrained_layout=True)
fig.set_constrained_layout_pads(w_pad=0, h_pad=0)
ax = fig.add_subplot(111)
ax.set_aspect('equal')
fig.canvas.draw()
bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
fig.set_size_inches(bbox[1][0]-bbox[0][0],bbox[1][1]-bbox[0][1])
fig.set_constrained_layout(False)
 for i in range(30):
    fig.canvas.draw()
    bbox = fig.get_tightbbox(fig.canvas.get_renderer()).get_points()
    print("%.16e"%bbox[0,0],bbox[1,0])

[ArchangeGabriel]

Well not using constrained_layout means the loop is useless. But if you do so and try saving, you end up with a cropped figure like this no_constrained_after_1st_draw.pdf. Maybe that’s the real bug though. BTW, tight_layout has the same issue here.