matplotlib-users Mailing List for matplotlib

What's new in matplotlib 0.51

Tkinter backend

  Todd Miller has written a Tkinter backend. This is a significant
  step forward, because now matplotlib works out of the box with any
  python + numeric. The Tkinter backend works interactively from any
  python shell - see the interactive documentation. Also, because
  TkAgg uses the agg backend for rendering, it has all of the features
  of agg, including fast antialiased rendering, freetype2, alpha
  blending, mathtext, and so on. See
  http://matplotlib.sf.net/backends.html#TkAgg. To use the TkAgg
  backend, you must launch your scripts in interactive mode

    > python -i myscript.py -dTkAgg

  otherwise they'll just pop up and disappear.

freetype2 support added for agg backend

  With freetype2, agg now renders fonts nicely even at very small
  raster sizes.

math text

  matplotlib now ships with the BaKoMa TeX Computer Modern fonts, and
  displays math text using TeX expressions. See screenshot
  http://matplotlib.sf.net/screenshots.html#mathtext_demo and the
  mathtext documentation
  http://matplotlib.sf.net/matplotlib.mathtext.html for usage
  information. Currently available on GTK, Agg, TkAgg and GTKAgg. If
  you build matplotlib yourself, you need to edit setup.py and set
  BUILD_FT2FONT

configuration file

  A configuration file is placed in your install path
  (distutils.sysconfig.PREFIX + 'share/matplotlib'). This determines
  many of the default figure properties: the default backend, line
  properties, text properties, colors, and more. See
  http://matplotlib.sf.net/.matplotlibrc for an example configuration
  file and details.  Place this in your home dir (linux and friends),
  or edit in the install path (windows).

numarray support

  Todd Miller has provided a numerix module
  http://matplotlib.sf.net/matplotlib.numerix.html which allows you to
  choose between Numeric of numarray. You can set Numeric or numarray
  in your matplotlibrc file, with an environment variable, or from the
  prompt. See the numerix module for more information and numarray
  issues http://matplotlib.sf.net/NUMARRAY_ISSUES for a summary of
  known issues in using numarray.

data clipping off by default

  Data clipping, as opposed to viewport clipping, is turned off by
  default. You can change the default behavior in .matplotlibrc or set
  it to be true when needed as in examples/stock_demo.py

kwargs in plot commands

  The plot commands now take kwargs that are can be used to set line
  properties (any property that has a set_* method). You can use this
  to set a line label (for auto legends), linewidth, anitialising,
  marker face color, etc. Here is an example:

    plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)
    plot([1,2,3], [1,4,9], 'rs',  label='line 2')
    axis([0, 4, 0, 10])
    legend()


Bugfixes and minor improvements

    * GTK : fixed a subplot selection GUI bug specific to python2.2
    * GTK : fixed a text layout bug 
    * ALL : Fixed a multiple column subplot layout bug
    * PS  : Fixed an afm parser - thanks Dominique
    * Agg : Agg now respects antialiased=False

Download: 

  http://sourceforge.net/project/showfiles.php?group_id=80706&package_id=82474&release_id=221304

>>>>> "Phil" == Phil Erickson <pj...@ha...> writes:

    Phil> Hello John, I have run into the following minor matplotlib
    Phil> bug.  Using the sample code below, the y axis label and tick
    Phil> marks in the second subplot seem not to be in the right
    Phil> places.  Also on that second subplot, the first legend is
    Phil> missing when the window is initially drawn, but gets redrawn
    Phil> correctly if I use the x axis interactive scrolling buttons.

Hi Phil,

Wow, that was a subtle one.  Thanks very much for a detailed
description, screenshot and demo code.  You can distill the essence of
the bug in this script

    from matplotlib.matlab import *

    subplot(211)
    plot([1,2,3])
    ylabel('Test me')

    subplot(212)
    plot([1,2,3])
    ylabel('Test me')

    show()

The key observation is that this script exposes the bug, but
examples/subplot_demo.py does not.  I found that if I commented out
the first ylabel the bug also disappeared.  This led me to the
solution.

I cache font instances in many of the backends since font creation and
drawing can be expensive, particularly on the GTK backend for vertical
text where I have to do the rotation by hand, pixel-by-pixel in
python.  In the cache I map text properties to font instances in a
dictionary.  As one of the properties, I was using the x, and y coords
of the text in *user* rather than *display* coords, so the second
ylabel was using the cached information of the first.  In the case of
the ylabels, the user coords are relative to their respective axes,
and so are identical for identical labels.

The same explanation applies to the legend code because the legends
had duplicate text.

A simple fix.  In matplotlib.text.py, on or around line 118 replace
get_prop_tup with

    def get_prop_tup(self):
        """
        Return a hashable tuple of properties

        Not intended to be human readable, but useful for backends who
        want to cache derived information about text (eg layouts) and
        need to know if the text has changed
        """

        x, y = self.get_xy_display()
        return (x, y, self._text, self._color,
        self._verticalalignment, self._horizontalalignment,
        self._fontname, self._fontsize, self._fontweight,
        self._fontangle, self._rotation, self.dpi.get())

The key is to use the display coords for the cache value.

Thanks again,
JDH

John Hunter wrote:
>>>>>>"Phil" == Phil Erickson <pj...@ha...> writes:
> 
> 
>     Phil> Hi all, I am really enjoying working with matplotlib and
>     Phil> hats off to an excellent effort.
> 
>     Phil>    I have done a cursory search of the mailing list archives
>     Phil> but didn't find the answer to a practical question that I
>     Phil> ran into in MATLAB all the time (which is where I'm coming
>     Phil> from in terms of familiarity).
> 
>     Phil>    Suppose I have an array to plot, and I want to exclude
>     Phil> certain points from being plotted.  In MATLAB, I would set
>     Phil> the y vector points I wanted excluded to "NaN" and then the
>     Phil> plot routine would draw connected lines up to the point
>     Phil> before the excluded one, skip the bad/not wanted point, and
>     Phil> then continue drawing lines beginning at the next point.
> 
>     Phil>    How does one accomplish that using matplotlib?  This
>     Phil> actually comes up quite often in our radar work here, in
>     Phil> cases where we are making log plots of vectors which may
>     Phil> contain zeros.
> 
> What matplotlib currently does is simply ignore non-positive data with
> an approach along the lines of
> 
>     ind = nonzero(y > 0)
>     validy = take(y, ind)
> 
> Just to make sure I'm understanding you properly, that's not a good
> solution for you because you want to the gap in the connected line
> where the complex (y<=0) points are.  Is this right?

That's right.  In our field, we often have data sets which have to be 
culled before plotting for points which might fail some sanity test like 
excessive variance, etc.  I'm sure other science data sets have a 
similar requirement.  For ease of use, I would definitely not want to 
have to break up my plot task into multiple lines myself by segmenting 
the incoming data, but rather have the method do it based on some signal 
value in the data.

In fact, the plots that I was trying to make were of a quantity which 
needs to be expressed in dB, which is

10 * log10(y)

So the problem is actually a bit more general, in that just calling 
semilogy() would make a plot of log10(y) which is not quite the same. 
For my needs, I have been using

plot(x, 10 * ProtectedLog(y))

where:

def ProtectedLog(a):
     "Calculate log10() but protect against non-positives."
     zeroIndex = find(a <= 0.0)
     b = array(a)
     for index in zeroIndex:
	# ideally we would use whatever value will
	# signal a non-plotted point; 1e-30 is
	# non-optimal
         b[index] = 1e-30
     c = log10(b)
     return c

Therefore, both plot() and semilogy() would have to pay attention to a 
special signal value.

> 
> What you describe is certainly possible but would impose a performance
> hit that depends on the number of separate connected lines that had to
> be constructed.  Eg, semilogy could find the non-positive indices and
> create the line segments appropriately.

Indeed, but your line drawing functions seem to be fast enough that 
maybe this isn't an issue.

> 
> As for NaN, I'm not an expert here.  As far as I understand, there is
> no support for it in Numeric but there is in numarray.  Look for basic
> numarray support in the next release.

All our code uses Numeric, so we have inertia working against us :)  NaN 
is for me just a value that I know MATLAB pays attention to when 
plotting.  If you had another way to put a value in, I could use that 
and all would be well.

Unfortunately, it seems Python has some trouble with IEEE standard 
values such as positive/negative infinity and NaNs.  There seems to be a 
pure Python package which would handle IEEE 754 standard NaN values at

http://www.analytics.washington.edu/Zope/projects/fpconst/

which perhaps might be a way to go.  The author has also made a request 
that this functionality be included in further Python releases.

cheers,
-- 
----
Phil Erickson                   email:  pj...@ha...
Atmospheric Sciences Group      WWW:    http://www.haystack.mit.edu
MIT Haystack Observatory        voice:  781 981 5769
Westford, MA  01886  USA        fax:    781 981 5766

Public key: http://pgp.mit.edu:11371/pks/lookup?op=get&search=0x54878872

>>>>> "Phil" == Phil Erickson <pj...@ha...> writes:

    Phil> Hi all, I am really enjoying working with matplotlib and
    Phil> hats off to an excellent effort.

    Phil>    I have done a cursory search of the mailing list archives
    Phil> but didn't find the answer to a practical question that I
    Phil> ran into in MATLAB all the time (which is where I'm coming
    Phil> from in terms of familiarity).

    Phil>    Suppose I have an array to plot, and I want to exclude
    Phil> certain points from being plotted.  In MATLAB, I would set
    Phil> the y vector points I wanted excluded to "NaN" and then the
    Phil> plot routine would draw connected lines up to the point
    Phil> before the excluded one, skip the bad/not wanted point, and
    Phil> then continue drawing lines beginning at the next point.

    Phil>    How does one accomplish that using matplotlib?  This
    Phil> actually comes up quite often in our radar work here, in
    Phil> cases where we are making log plots of vectors which may
    Phil> contain zeros.

What matplotlib currently does is simply ignore non-positive data with
an approach along the lines of

    ind = nonzero(y > 0)
    validy = take(y, ind)

Just to make sure I'm understanding you properly, that's not a good
solution for you because you want to the gap in the connected line
where the complex (y<=0) points are.  Is this right?

What you describe is certainly possible but would impose a performance
hit that depends on the number of separate connected lines that had to
be constructed.  Eg, semilogy could find the non-positive indices and
create the line segments appropriately.

As for NaN, I'm not an expert here.  As far as I understand, there is
no support for it in Numeric but there is in numarray.  Look for basic
numarray support in the next release.

JDH

>>>>> "Kuzminski," == Kuzminski, Stefan R <SKu...@fa...> writes:

    Kuzminski> I tried the new Agg backend, very nice.  I'm all set
    Kuzminski> to jettison GD altogether and go with Agg except that
    Kuzminski> the anti-aliased graphs that look so great, print
    Kuzminski> poorly.. :-( Is there a way to turn off the
    Kuzminski> anti-aliasing?  It would be *great* to be able to drop
    Kuzminski> that GD dependency.

agg plus/minus antialiasing is included in the next release, due out
soon.  Alpha version is here if you want to test.  Please report any
problems.

http://nitace.bsd.uchicago.edu:8080/files/share/matplotlib-0.51g.win32-py2.3.exe

JDH

Hello,
 
I'm trying to convert my python program that uses matplotlib to an exe
using py2exe and I'm having a problem. 
Running
>python setup.py py2exe
works fine and creates files in the /dist path. However, when I run the
.exe I get a runtime error (see below)
 
Traceback (most recent call last):
  File "out2jpg.py", line 124, in ?
  File "matplotlib\matlab.pyc", line 497, in figure
  File "matplotlib\backends\backend_wx.pyc", line 1066, in
new_figure_manager
  File "matplotlib\backends\backend_wx.pyc", line 1094, in __init__
  File "matplotlib\backends\backend_wx.pyc", line 1320, in __init__
  File "matplotlib\backends\backend_wx.pyc", line 1340, in
_create_controls
  File "matplotlib\backends\backend_wx.pyc", line 1191, in _load_bitmap
  File "matplotlib\__init__.pyc", line 157, in get_data_path
RuntimeError: Could not find the matplotlib data files
 
--Matt