matplotlib-users Mailing List for matplotlib

>
> "Alexander Michael" <[EMAIL PROTECTED]> writes:
>
> > I would like to create a plot axis with major tick labels centered
> > *between* major tick markers instead below tick markers.
>
> Take a look at
>
> http://thread.gmane.org/gmane.comp.python.matplotlib.general/5271
> http://thread.gmane.org/gmane.comp.python.matplotlib.general/5296
> http://www.scipy.org/Cookbook/Matplotlib/Transformations
>
> --
> Jouni
>
>
>From your references, I have been mostly able to figure out how to do it.
Thank you.
So far, I have:
# create transformation with x in data coords and y in axes coordinates
transLabels = matplotlib.transforms.blend_xy_sep_transform(
 ax.transData, ax.transAxes)
# get major locator and usurp major formatter for custom positioning
major_locator = ax.xaxis.get_major_locator()
major_formatter = ax.xaxis.get_major_formatter()
ax.xaxis.set_major_formatter(matplotlib.ticker.NullFormatter())
# create custom text labels centered between major tick marks
major_locs = major_locator()
for i in range(1,len(major_locs)):
 x_last,x = major_locs[i-1],major_locs[i]
 ax.text(0.5*(x+x_last), -0.04, major_formatter(x, i),
 transform=transLabels, horizontalalignment='center')
When "zooming around" an interactive plot, however, my custom labels get
pushed
off into the margins. I'm guessing I need to put them in a clip box somehow.
Any hints?
Thanks!
Alex

Thanks for the detailed reply. I was just wondering whether I was 
missing something obvious and
that doesn't seem to be the case.
Cheers
Daniel Wheeler
On Aug 2, 2006, at 2:15 PM, John Hunter wrote:
>>>>>> "Daniel" == Daniel Wheeler <dan...@ni...> writes:
>
> Daniel> It seems that resetting the axes limits every time data
> Daniel> needs to be redisplayed is rather inefficient. A script
> Daniel> is included with this mail that tests the efficiency of
> Daniel> resizing the y axis. The script has two loops, in the
> Daniel> first loop pylab.ylim() is continuously called with the
> Daniel> changing size of the domain, in the second loop
> Daniel> pylab.ylim() is not called inside the loop. The first loop
> Daniel> takes roughly twice as long to perform. Is this an
> Daniel> unavoidable cost for resizing the y axis or is there
> Daniel> another way to resize the axis that is less costly than
> Daniel> using ylim()?
>
> The cost from the tick layout and formatting -- this could be made
> more efficient but that is where the cost is currently. For every
> tick label, matplotlib does a layout assuming you may have passed a
> rotated multiline string. Special casing the no newline, non-rotated
> case is probably where the biggest win would come from. It is
> a good project for someone to tackle, but the text layout code is kind
> of hairy because it deals with so many cases: mathtext, usetex,
> rotated strings, multiline strings, top/bottom left/right alignment,
> and so on.
>
> A complete refactoring of ticks to treat them as a single
> collection-like object rather than a bunch of independent objects
> would also help a lot here.
>
> JDH
Daniel Wheeler

>>>>> "Daniel" == Daniel Wheeler <dan...@ni...> writes:
 Daniel> It seems that resetting the axes limits every time data
 Daniel> needs to be redisplayed is rather inefficient. A script
 Daniel> is included with this mail that tests the efficiency of
 Daniel> resizing the y axis. The script has two loops, in the
 Daniel> first loop pylab.ylim() is continuously called with the
 Daniel> changing size of the domain, in the second loop
 Daniel> pylab.ylim() is not called inside the loop. The first loop
 Daniel> takes roughly twice as long to perform. Is this an
 Daniel> unavoidable cost for resizing the y axis or is there
 Daniel> another way to resize the axis that is less costly than
 Daniel> using ylim()?
The cost from the tick layout and formatting -- this could be made
more efficient but that is where the cost is currently. For every
tick label, matplotlib does a layout assuming you may have passed a
rotated multiline string. Special casing the no newline, non-rotated
case is probably where the biggest win would come from. It is
a good project for someone to tackle, but the text layout code is kind
of hairy because it deals with so many cases: mathtext, usetex,
rotated strings, multiline strings, top/bottom left/right alignment,
and so on.
A complete refactoring of ticks to treat them as a single
collection-like object rather than a bunch of independent objects
would also help a lot here.
JDH

It seems that resetting the axes limits every time data needs to be =20
redisplayed is rather inefficient.
A script is included with this mail that tests the efficiency of =20
resizing the y axis.
The script has two loops, in the first loop pylab.ylim() is =20
continuously called with the changing
size of the domain, in the second loop pylab.ylim() is not called =20
inside the loop. The first loop takes roughly
twice as long to perform.
Is this an unavoidable cost for resizing the y axis or is there =20
another way to resize the axis that is less costly
than using ylim()?
=EF=BF=BC
Cheers
Daniel Wheeler