matplotlib-users Mailing List for matplotlib

Eric Firing wrote:

>
> An alternative would be to use a locking mechanism to ensure that your 
> plotting function runs from start to end without interruption by 
> another thread.
>

Thanks.  I'm now controlling access with a lock object and it's working 
fine.

-Steve

Steve,

I think the short answer is that the pylab interface is inherently 
single-threaded; it is intended to facilitate interactive plotting.  It 
has a single list of figures, a concept of a single current figure, and 
within that a single current axes.  If you use more than one thread, 
then thread B is liable to change the current figure or axes while 
thread A is in the middle of doing something with it.  It is a recipe 
for chaos.

Careful adherence to the Object-oriented interface that underlies the 
pylab interface should mostly solve the problem, because then each 
thread should be operating on its own figure and axes. I said "mostly" 
because there is still the global rcParams dictionary; you will need to 
be sure that your plotting threads treat it as read-only.  There may be 
other such things that have not occurred to me.

An alternative would be to use a locking mechanism to ensure that your 
plotting function runs from start to end without interruption by another 
thread.

Eric

Steve Bergman wrote:
> I am using the method below to dynamically generate pie charts in my 
> TurboGears/CherryPy web app.  Everything works fine until I increase the 
> number of application threads allowed to > 1.
> 
> Then all manner of wierdness occurs.  Pies charts which are not scaled 
> properly, which have the various wedges scaled differently from each 
> other, and incomplete pie charts.
> 
> Am I doing something wrong?
> 
>  def pie_chart(self, **kw):
>    figure(1, figsize=(0.75,0.75), frameon=False)       ax = axes([0.1, 
> 0.1, 0.8, 0.8])
>    labels = 'Contract', 'Billable', 'Unbillable', 'Nonbill'
>    billable=float(kw['billable'])
>    contract=float(kw['contract'])
>    unbillable=float(kw['unbillable'])
>    nonbill=float(kw['nonbill'])
>    fracs = [contract,billable, unbillable,nonbill]
>    fig = pie(fracs, shadow=False, colors=('#70A0A0', 
> '#C0F090','#C03030',  '#FFFFFF'))
>    fname = os.tmpnam() + ".png"
>    savefig(fname)
>    f=open(fname,'r')
>    x=f.read()
>    f.close()
>    os.remove(fname)
>    pylab.close()
>    return (x)
> 
> 
> -------------------------------------------------------
> This SF.Net email is sponsored by xPML, a groundbreaking scripting language
> that extends applications into web and mobile media. Attend the live 
> webcast
> and join the prime developer group breaking into this new coding territory!
> http://sel.as-us.falkag.net/sel?cmd=lnk&kid=110944&bid=241720&dat=121642
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users

I am using the method below to dynamically generate pie charts in my 
TurboGears/CherryPy web app.  Everything works fine until I increase the 
number of application threads allowed to > 1.

Then all manner of wierdness occurs.  Pies charts which are not scaled 
properly, which have the various wedges scaled differently from each 
other, and incomplete pie charts.

Am I doing something wrong?

  def pie_chart(self, **kw):
    figure(1, figsize=(0.75,0.75), frameon=False)    
    ax = axes([0.1, 0.1, 0.8, 0.8])
    labels = 'Contract', 'Billable', 'Unbillable', 'Nonbill'
    billable=float(kw['billable'])
    contract=float(kw['contract'])
    unbillable=float(kw['unbillable'])
    nonbill=float(kw['nonbill'])
    fracs = [contract,billable, unbillable,nonbill]
    fig = pie(fracs, shadow=False, colors=('#70A0A0', 
'#C0F090','#C03030',  '#FFFFFF'))
    fname = os.tmpnam() + ".png"
    savefig(fname)
    f=open(fname,'r')
    x=f.read()
    f.close()
    os.remove(fname)
    pylab.close()
    return (x)

I am using pylab in a web application server (TurboGears/CherryPy). 

I need to be able to render a plot (actually a pie) in png, jpg, or gif 
format directly into a variable that I can return to the application 
server.  I'm currently using the rather ugly method of writing to a temp 
file and then reading it back in and returning the data.  Is there a way 
to do this completely in memory?

Thanks,
Steve Bergman