Crudely: I'm looking for something just as simple in
> matplotlib.matlab. My last post outlined what I think the
> current procedure is to achieve the same effect, and it is
> much more cumbersome. While this matters little when one is
> leisurely writing a script, it matters a lot when one is
> doing interactive plotting in a classroom setting.
> Now you point out that this request has an ambiguity: what
> "physical" medium am I talking about? Specifically, a true
> compression ratio on screen requires tricky stuff if dpiy !=
> dpix. OK, I assume ignoring this will yield a "close
> enough" result in a classroom setting, so the only time I
> need it to be exact is when I produce figures for paper
> display.
w/o having to worry about dpi differences in the x and y direction, it
is much easier, and your hardcopy will be correct in any case.
Do you really need arbitrary compression ratios, or just ratios equal
to 1. I added the option 'equal' to the axis command, which simply
sets the xlim and ylim to be equal and includes the range of both.
I'll include the modified axis method from matlab.py at the end of
this email. Thus you can do
from matplotlib.matlab import *
figure(figsize=(6,6))
ax = axes([0.1, 0.1, 0.8, 0.8])
plot(rand(100), rand(100), 'o')
axis('equal')
show()
Admittedly this is more typing than you want to do in an interactive
session. I experimented with a function 'square' which isn't the
right name but you get the idea. It handles setting the figure size,
axes ratio and lim ratio for you. Some suitably named function could
be included in the standard interface
from matplotlib.matlab import *
def square():
fig = gcf()
ax = gca()
figw, figh = fig.get_size_inches()
l,b,axw,axh = ax.get_position()
side = min([figw, figh])
frac = min([axw, axh])
fig.set_figsize_inches(side, side)
ax.set_position([l,b,frac,frac])
axis('equal')
draw()
plot(rand(100), rand(100), 'o')
square()
show()
It's the right idea, but it doesn't work currently if you are using a
GUI backend. The reason it fails is has to do with the pipeline order
in which figure managers, figures etc are created by default, and the
fact that configure events and resize events change the figure width
and height (so you can for example, resize your figure window). It
*does* work if you specify the figure size
figure(figsize=(8,8))
plot(rand(100), rand(100), 'o')
square()
show()
because then matplotlib has the information it needs at figure
creation time. Of course, you can set the figure size to have a unity
aspect ratio in your rc file and then you could do without the figsize
command altogether. I'll think about how to best fix the GUI resizing
problem. I'll probably need to add an observer to the figure limits
so that the GUI backend can update its size from script calls to
figure size. As an aside, traits are starting to look very useful,
with their build in observer framework.
For now, any feedback on whether this approach looks like the right
one, whether any ratios other than 1 are actually needed, what the
function square should be called and anything else is welcome.
JDH
def axis(*v):
"""
axis() returns the current axis as a length a length 4 vector
axis(v) where v= [xmin xmax ymin ymax] sets the min and max of the
x and y axis limits
axis('off') turns off the axis lines and labels
axis('equal') sets the xlim and ylim to be identical
"""
if len(v)==1 and is_string_like(v[0]):
s = v[0]
if s.lower()=='on': gca().set_axis_on()
elif s.lower()=='off': gca().set_axis_off()
elif s.lower()=='equal':
ax = gca()
xmin, xmax = ax.get_xlim()
ymin, ymax = ax.get_ylim()
vmin = min([xmin, ymin])
vmax = max([xmax, ymax])
ax.set_xlim((vmin, vmax))
ax.set_ylim((vmin, vmax))
draw_if_interactive()
else:
error_msg('Unrecognized string %s to axis; try on or off' % s)
return
try: v[0]
except IndexError:
xlim = gca().get_xlim()
ylim = gca().get_ylim()
return [xlim[0], xlim[1], ylim[0], ylim[1]]
v = v[0]
if len(v) != 4:
error_msg('v must contain [xmin xmax ymin ymax]')
return
gca().set_xlim([v[0], v[1]])
gca().set_ylim([v[2], v[3]])
draw_if_interactive()