matplotlib-users Mailing List for matplotlib

Rob,

This is now in svn, for pcolor only, not for pcolormesh.  Please check 
it out.  If everything is OK I can add it to pcolormesh as well 
(although pcolormesh still has a deeply-buried bug such that it does not 
work with alpha != 1).

Eric

Robert Hetland wrote:
> 
> I would like to propose expanding the inputs of pcolor to take vectors.  
> Often, you have x and y independent (seperable), and you don't want to 
> go on constructing an x array of redundant values.  Actually, in NumPy 
> it is not straightforward to do this with resize if your variable is in 
> the first dimension like time (well, there is meshgrid, but you would 
> only use it for plotting, and with two vectors -- see below).  Since 
> NumPy makes such heavy use of array broadcasting, it is not necessary.
> 
> I think MPL should follow the spirit of array broadcasting, and make it 
> such that:
> 
> x = arange(10)
> y = arange(30)
> z = rand(30,10)
> pcolor (x, y, z)
> 
> will work as expected.  Perhaps, we could require a NewAxis in the right 
> places, but it would also make sense without. You should also be able to 
> send in just one vector.  Consider
> 
> x,y = meshgrid(arange(10), arange(30))
> y = y + random.normal(size=y.shape)
> z = random.random(y.shape)
> pcolor (x, y, z)
> % but x is still essentially just arange(10)
> pcolor(arange(10), y, z)
> 
> What do you all think?
> 
> -Rob.
> 
> 
> -----
> Rob Hetland, Assistant Professor
> Dept of Oceanography, Texas A&M University
> p: 979-458-0096, f: 979-845-6331
> e: he...@ta..., w: http://pong.tamu.edu
> 

Sorry meant to send this to the whole list:
----------------------------

John,

Thanks for the fix.  After reading Eric's email I started to question
my profiling results but I still (without your fix) seem to see a
significant time when in Artist when generating large volumes of
graphs.  I need to rebuild my matplotlib against svn and test your fix
now to see if that solves the problem.

Thanks for your help.


--Tom



On 12/5/06, John Hunter <jdh...@ac...> wrote:
> >>>>> "Christopher" == Christopher Barker <Chr...@no...> writes:
>
>    Christopher> This sounds like a job for properties! make
>    Christopher> _transform a property, and code that gets and sets it
>    Christopher> directly should still work. though People that were
>    Christopher> accessing an underscored name directly should expect
>    Christopher> this kind of problem.
>
> The matplotlib artist kwarg properties act like python properties or
> enthought traits, with some advantages and disadvantages over each
> (mostly disadvantages, alas).  We've discussed migrating to one or
> another over the years, but haven't bitten the bullet.  At each point
> it's easier to extend the exiting implementation than refactor the
> whole bit; the tyranny of small decisions.
>
> Here are some of the pros and cons as I see them of enthought traits
> vs python properties
>
>   Pros:
>   * compatibility with the rest of the enthought tool suite
>   * built in observer pattern
>   * automatic UI for wx users
>   * performance is better than python properties last time I looked
>   * matplotlib ships with enthought traits built in
>
>   Cons:
>   * smaller user base than python properties may imply
>     fewer 3rd party enhancements, less support, etc
>   * we have to maintain our copy of enthought traits to keep it
>     current and building or require an additional dependency
>
> I spent some time working on matplotlib rc properties as enthought
> traits as a precursor to porting matplotlib properties to traits.
> Here is some example code showing how to define some representative rc
> properties and construct a matplotlib artist using traits.  Because
> matplotlib ships with enthought traits already, you can run this
> script with just matplotlib.  Unfortunately, we do not ship the ex UI
> component so you can't test that part.  I'm  a bit of a traits newbie
> so there are probably better ways to do what I have done below.
>
> import sys, os, re
> import matplotlib.enthought.traits as traits
> from matplotlib.cbook import is_string_like
> from matplotlib.artist import Artist
>
> doprint = True
> flexible_true_trait = traits.Trait(
>    True,
>    { 'true':  True, 't': True, 'yes': True, 'y': True, 'on':  True, True: True,
>      'false': False, 'f': False, 'no':  False, 'n': False, 'off': False, False: False
>                               } )
> flexible_false_trait = traits.Trait( False, flexible_true_trait )
>
> colors = {
>    'c' : '#00bfbf',
>    'b' : '#0000ff',
>    'g' : '#008000',
>    'k' : '#000000',
>    'm' : '#bf00bf',
>    'r' : '#ff0000',
>    'w' : '#ffffff',
>    'y' : '#bfbf00',
>    'gold'                 : '#FFD700',
>    'peachpuff'            : '#FFDAB9',
>    'navajowhite'          : '#FFDEAD',
>    }
>
> def hex2color(s):
>    "Convert hex string (like html uses, eg, #efefef) to a r,g,b tuple"
>    return tuple([int(n, 16)/255.0 for n in (s[1:3], s[3:5], s[5:7])])
>
> class RGBA(traits.HasTraits):
>    # r,g,b,a in the range 0-1 with default color 0,0,0,1 (black)
>    r = traits.Range(0., 1., 0.)
>    g = traits.Range(0., 1., 0.)
>    b = traits.Range(0., 1., 0.)
>    a = traits.Range(0., 1., 1.)
>    def __init__(self, r=0., g=0., b=0., a=1.):
>        self.r = r
>        self.g = g
>        self.b = b
>        self.a = a
>    def __repr__(self):
>        return 'r,g,b,a = (%1.2f, %1.2f, %1.2f, %1.2f)'%\
>               (self.r, self.g, self.b, self.a)
>
> def tuple_to_rgba(ob, name, val):
>    tup = [float(x) for x in val]
>    if len(tup)==3:
>        r,g,b = tup
>        return RGBA(r,g,b)
>    elif len(tup)==4:
>        r,g,b,a = tup
>        return RGBA(r,g,b,a)
>    else:
>        raise ValueError
> tuple_to_rgba.info = 'a RGB or RGBA tuple of floats'
>
> def hex_to_rgba(ob, name, val):
>    rgx = re.compile('^#[0-9A-Fa-f]{6}$')
>
>    if not is_string_like(val):
>        raise TypeError
>    if rgx.match(val) is None:
>        raise ValueError
>    r,g,b = hex2color(val)
>    return RGBA(r,g,b,1.0)
> hex_to_rgba.info = 'a hex color string'
>
> def colorname_to_rgba(ob, name, val):
>    hex = colors[val.lower()]
>    r,g,b =  hex2color(hex)
>    return RGBA(r,g,b,1.0)
> colorname_to_rgba.info = 'a named color'
>
> def float_to_rgba(ob, name, val):
>    val = float(val)
>    return RGBA(val, val, val, 1.)
> float_to_rgba.info = 'a grayscale intensity'
>
>
>
> Color = traits.Trait(RGBA(), float_to_rgba, colorname_to_rgba, RGBA,
>              hex_to_rgba, tuple_to_rgba)
>
> def file_exists(ob, name, val):
>    fh = file(val, 'r')
>    return val
>
> def path_exists(ob, name, val):
>    os.path.exists(val)
> linestyles  = ('-', '--', '-.', ':', 'steps', 'None')
> TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN = range(4)
> linemarkers = (None, '.', ',', 'o', '^', 'v', '<', '>', 's',
>                  '+', 'x', 'd', 'D', '|', '_', 'h', 'H',
>                  'p', '1', '2', '3', '4',
>                  TICKLEFT,
>                  TICKRIGHT,
>                  TICKUP,
>                  TICKDOWN,
>                  'None'
>               )
>
> class LineRC(traits.HasTraits):
>    linewidth       = traits.Float(0.5)
>    linestyle       = traits.Trait(*linestyles)
>    color           = Color
>    marker          = traits.Trait(*linemarkers)
>    markerfacecolor = Color
>    markeredgecolor = Color
>    markeredgewidth = traits.Float(0.5)
>    markersize      = traits.Float(6)
>    antialiased     = flexible_true_trait
>    data_clipping   = flexible_false_trait
>
> class PatchRC(traits.HasTraits):
>    linewidth       = traits.Float(1.0)
>    facecolor = Color
>    edgecolor = Color
>    antialiased     = flexible_true_trait
>
> timezones = 'UTC', 'US/Central', 'ES/Eastern' # fixme: and many more
> backends = ('GTKAgg', 'Cairo', 'FltkAgg', 'GD', 'GDK', 'GTK', 'Agg',
>            'GTKCairo', 'Paint', 'PS', 'SVG', 'Template', 'TkAgg',
>            'WX')
>
> class RC(traits.HasTraits):
>    backend = traits.Trait(*backends)
>    numerix = traits.Trait('Numeric', 'numarray')
>    interactive  = flexible_false_trait
>    toolbar      = traits.Trait('toolbar2', 'classic', None)
>    timezone     = traits.Trait(*timezones)
>    lines        = traits.Trait(LineRC())
>    patch        = traits.Trait(PatchRC())
>
> rc = RC()
> rc.lines.color = 'r'
> if doprint:
>    print 'RC'
>    rc.print_traits()
>    print 'RC lines'
>    rc.lines.print_traits()
>    print 'RC patches'
>    rc.patch.print_traits()
>
>
> class Patch(Artist, traits.HasTraits):
>    linewidth = traits.Float(0.5)
>    facecolor = Color
>    fc = facecolor
>    edgecolor = Color
>    fill = flexible_true_trait
>    def __init__(self,
>                 edgecolor=None,
>                 facecolor=None,
>                 linewidth=None,
>                 antialiased = None,
>                 fill=1,
>                 **kwargs
>                 ):
>        Artist.__init__(self)
>
>        if edgecolor is None: edgecolor = rc.patch.edgecolor
>        if facecolor is None: facecolor = rc.patch.facecolor
>        if linewidth is None: linewidth = rc.patch.linewidth
>        if antialiased is None: antialiased = rc.patch.antialiased
>
>        self.edgecolor = edgecolor
>        self.facecolor = facecolor
>        self.linewidth = linewidth
>        self.antialiased = antialiased
>        self.fill = fill
>
>
> p = Patch()
> p.facecolor = '#bfbf00'
> p.edgecolor = 'gold'
> p.facecolor = (1,.5,.5,.25)
> p.facecolor = 0.25
> p.fill = 'f'
> print 'p.facecolor', type(p.facecolor), p.facecolor
> print 'p.fill', type(p.fill), p.fill
> if p.fill_: print 'fill'
> else: print 'no fill'
> if doprint:
>    print
>    print 'Patch'
>    p.print_traits()
>
>
>
> JDH
>
> -------------------------------------------------------------------------
> Take Surveys. Earn Cash. Influence the Future of IT
> Join SourceForge.net's Techsay panel and you'll get the chance to share your
> opinions on IT & business topics through brief surveys - and earn cash
> http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

>>>>> "Pellegrini" == Pellegrini Eric <eri...@ya...> writes:

    Pellegrini> Hi everybody, I would like to build an application
    Pellegrini> where many filled polygons will have to be displayed
    Pellegrini> on the screen. To do so, I would like to use
    Pellegrini> matplotlib but, up to now, my application is not fast
    Pellegrini> enough.

Hmm, I'm not seeing the performance problem on my system -- I can
create and save the figure in a fraction of a second.  Is your numerix
setting set to numpy?  Run the script with --verbose-helpful and send
us the output.

A few things to note: if you really want regular polygons, eg the
squared in your example, do any of the plot markers work for you.

plot(x, marker='s')

will be about as fast as mpl gets.  You can set the marker size with
the markersize property.

Second, if you need arbitrary polygons, and need a lot of them, a
polygon collection will be faster.  I had to bump the number of polys
up to about 8000 to show a dramatic performance difference.

Here are two scripts and performance numbers -- one using fill and one
using a polygon collection

> time python test.py -dAgg
6.595u 0.089s 0:06.68 99.8%     0+0k 0+0io 0pf+0w

> time python test2.py -dAgg
0.565u 0.033s 0:00.59 100.0%    0+0k 0+0io 0pf+0w

> cat test.py
import pylab

x = range(0,81000,10)
pylab.axis('off')
for i in range(0,len(x)-1):
    pylab.fill([x[i],x[i+1],x[i+1],x[i]],[10,10,20,20])
pylab.axis((0,max(x),0,610))
pylab.savefig('test')
pylab.show()

> cat test2.py
import pylab
from matplotlib.collections import PolyCollection
fig = pylab.figure()
ax = fig.add_subplot(111)
x = range(0,81000,10)

pylab.axis('off')
verts = [((x[i], 10), (x[i+1], 10), (x[i+1], 20), (x[i], 20)) for i in range(len(x)-1)]
col = PolyCollection(verts)
ax.add_collection(col)
pylab.axis((0,max(x),0,610))
pylab.savefig('test')
pylab.show()

Hi everybody,

I would like to build an application where many filled polygons will have to be displayed on the screen. To do so, I would like to use matplotlib but, up to now, my application is not fast enough.

I use:
python 2.4.1
matplot-0.87.6
numpy-1.0rc1

and  I checked my matplotlibrc file, the interactive flag is False.

Here is a little script that illustrates my problem. It takes something like 5-10s to display 80 polygons on the screen using a brand new machine.

###########################################

import pylab

x = range(0,810,10)
pylab.axis('off')
for i in range(0,len(x)-1):
    pylab.fill([x[i],x[i+1],x[i+1],x[i]],[10,10,20,20])
pylab.axis((0,810,0,610))

########################################

would you have any idea of what is going on or of a better way to implement this ?

Thank you very much

Eric
 		
---------------------------------
 Découvrez une nouvelle façon d'obtenir des réponses à toutes vos questions ! Profitez des connaissances, des opinions et des expériences des internautes sur Yahoo! Questions/Réponses.