matplotlib-users Mailing List for matplotlib

John,

I've been meaning to ask you ...  how did you produce the very fine User 
Guide?  Is that TeXmacs?  LyX?  raw LaTeX?  ConTeXt?  emacs magic?


Is there some slick way of getting the listings from the command line 
window into the document, especially with the comments colorized?  I'm 
writing a small local guide, and was wondering ...


-gary

>>>>> "James" == James Boyle <bo...@ll...> writes:

    James> Is there anyway to place the tick marks so that they are
    James> located outside the axes, i.e. on the same side of the axis
    James> line as the axis labels?

    James> With plots such as imshow and pcolor and even some busy
    James> line plots, the interior minor ticks are completely
    James> obscured and the exact location of the major ticks is
    James> ambiguous.

    James> It would be nice to be able to specify the ticks as inside
    James> or outside (or both), right or left (or both), top or
    James> bottom (or both). This functionality may already be present
    James> but I cannot figure out how to invoke it if it is.

I would like to make tick placement more flexible, for example to
support a detachable tick line so the axis line, tick lines and labels
float below the axes boundary.  In addition, I would like the ability
to position ticks along this line as above, centered or below, as you
suggest.  But for now this doesn't exist, but you can hack an
approximation.

The tick markers are TICKUP, TICKDOWN, TICKLEFT, and TICKRIGHT,
and these are constants in matplotlib.lines.  You can set the tick
markers, for example, to be TICKDOWN.  But you'll have to manually
adjust the y position of the labels to be below them.  

The second hack is this only works in interactive mode.  ticks are
generated dynamically (eg for panning and zooming) and the ticks
aren't generated until the plot is show.  In non-interactive mode, the
change of the default tick's line style is not propogating to the new
ticks that are dynamically generated when the line is shown.  This
appears to be a bug so I'll look into it.  For now, though, you should
be able to get something that works in non-interactive mode.

import matplotlib
matplotlib.interactive(True)
import matplotlib.lines as mpllines
import pylab as pl

ax = pl.subplot(111)
pl.plot([1,2,3])
lines = ax.get_xticklines()
labels = ax.get_xticklabels()

for line in lines:
    line.set_marker(mpllines.TICKDOWN)

# labels are in axes coords, where 0,0 is lower left of axes rectangle
# and 1,1 is upper right
for label in labels:
    label.set_y(-0.02)
pl.show()

>>>>> "seberino" == seberino  <seb...@sp...> writes:

    seberino> Imagine your arrays had points (Cartesian position
    seberino> vectors) all over the place at completely random points
    seberino> in space.  The 'shape' of this plot depends on max and
    seberino> min values of each coordinate.  I believe Mathematica
    seberino> plotting would automagically calculate these max and min
    seberino> values and set plot ranges for you.  This is why 'shape'
    seberino> attribute of Matplotlib/Numarray seems awkward and
    seberino> unnecessary to me unless I'm missing something.

There are a variety of issues here.  

  - The "shape" attribute comes form Numeric/numarray and is outside
    the realm of matplotlib.  matplotlib plots numerix arrays.  

  - The pcolor interface is determined by matlab.  matlab has a pcolor
    function which I have tried to implement faithfully.  To the
    extent that matplotlib has been successful, this is due in part
    because matlab has a good interface for plotting and replicating
    it generally, is a good thing.

  - Storing the "shape" of a data set allows for memory and efficiency
    savings.  To take your example of a set of x,y,z points, you are
    right you cold reconstruct rectilinear grid from this data -- one
    might have to use interpolation but it can be done -- but it would
    require a lot of unnecessary computation for data which already
    lives on a grid.  So pcolor assumes your data are on a rectilinear
    grid and it is incumbent upon you to get it into that form.
    
    The meshgrid function takes regularly sampled vector data and
    turns it into a rectilinear grid (this is also a matlab function).
    The matlab griddata function (which is not yet implemented in
    matplotlib) does the same for irregularly sampled data.

JDH

Hi,

When trying to plot the contours of the famous Rosenbrock function:

----------------------------------------
from matplotlib.pylab import *

def rosenbrock(x,y):
     return 10.0 * (y-x**2)**2 + (x-1)**2

x = arange( -1.5, 1.5, 0.01 )
y = arange( -0.5, 1.5, 0.01 )
[X,Y] = meshgrid( x, y )
Z = rosenbrock( X, Y )
contour( Z, x=X, y=Y, levels = 50 )
show()
----------------------------------------

I notice some spurious zigzagging lines towards the top of the plot. Any 
idea where those might be coming from?

Also, the figure produced by the above script is flipped horizontally. 
The corresponding Matlab script produces the correct plot.

Thanks,
Dominique