matplotlib-users Mailing List for matplotlib

On Tue, Aug 21, 2007 at 01:14:44PM +0100, Alex Pounds wrote:
> 4. I need to stick a footnote in the bottom corner of my charts. Can I do
> this natively in matplotlib or will I have to do it with a separate library
> afterwards?
For the sake of others searching the archives, here are the answers I've
found out for myself so far: 
4. You can do this with matplotlib: 
figtext(0.98, 0.05, u'©2007 Alexpounds.com', ha='right')
This puts a copyright notice in the bottom right of a chart. 
> 5. Can I have my xtick labels oriented vertically? 
Yep. Just pass rotation="vertical" in to xticks(). Easy. Though this may
overlap with the figtext above - I haven't got that bit sorted yet...
-- 
Alex Pounds (Creature) .~. http://www.alexpounds.com/
 /V\ http://www.ethicsgirls.com/
 // \\
"Variables won't; Constants aren't" /( )\
 ^`~'^

How do I set my vertical bar to be fixed width? Depending on amount of
data on my x axis, the bars get created accordingly and the width gets
adjusted to fit into the graph. If I have only 2 plots on the x axis
then the 2 bars get stretched across the entire graph. Looks very
ugly.
-Alen

> > 
> > I am but a humble newbie, but why not simply take your figure
> > object/reference and Pickle it (see
> > http://docs.python.org/lib/module-pickle.html)?
> > 
> 
> Won't work. Pickling only works for objects that have been designed for 
> it. Such design is not trivial for extension code, and has not been 
> done for mpl.
I keep coming back to this from time-to-time and have a go a poking
around in the mpl codebase but I've never figured out exactly what state
the matplotlib "Lazy Values" and "BinOps" store. 
If this internal state could be retrieved and then later restored, then
python can pickle the extension objects using the copy-reg module. It
might be enough if methods were added to the BinOp objects to retrieve
internal objects to which they link. You could then recursively walk
through the whole lazy-value tree. To make this work, you would need to
retrieve the underlying C++ objects with it's python wrapper object
intact (i.e. with the same IDs) so that python references to that object
created elsewhere still work.
While the concept of Lazy Values is easy enough to understand,
understanding how and where these objects fit in to the MPL architecture
is hard. I think a little documentation or explanation of this could go
a long way to helping implement this. If I could understand all the
places the Lazy Values are used, I'm keen to attempt the implementation
of pickle-ability. One problem for me is my C++ knowledge is ~ 0.
BC
> 
> Eric
> 
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems? Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/

Hi Eric,
On 23/08/07, Eric Emsellem <ems...@ob...> wrote:
> thanks a lot for this feedback!
>
> Your example is quite nice indeed. However there is something I may not
> have fully understand.
> If I use the example you sketch, I of course need to call the displayer
> class (right?), by doing something like:
>
> test = displayer()
>
> However, then I hit the same problem again: I would need to define ALL
> the commands I wish to go through WITHIN the displayer class (and more
> precisely into the "show_next" function), because any command put after
> the "test = displayer()" would be executed anyway without waiting that I
> finally hit the right mouse button.
I'm not sure why this is a problem. Yes, you need to put all your code
into the callback routines of displayer, but just think of it as
wrapping your program code inside the class. Your __main__ code then
simply becomes test = displayer()... and away you go.
Also, I realised shortly after sending my email that you can of course
do away with the offset class in this example, and put those methods
into the displayer class too, which will make things a little simpler.
> Or is there something I didn't catch which would allow me to go around this?
>
> (what my program is supposed to do at the end is to go through a series
> of (3xdataframes), and for each dataframe in turn, use the "offset"
> trick, then reinitialise everything and start with the next series...
> This seems to imply that I need to specify the full set of commands
> within the displayer class show_next function)
>
> thanks again
>
> Eric
Angus.
-- 
AJC McMorland, PhD Student
Physiology, University of Auckland

Alex Pounds wrote:
> On Thu, August 23, 2007 5:33 pm, David Tremouilles wrote:
>> I would like to save a matplotlib figure (data, title and axes label,
>> plot properties, ...) to load it later on for modification. Something
>> like figure.savelall("file.matplot") and later on do a
>> figure.loadall("file.matplot") using an empty figure.
> 
> I am but a humble newbie, but why not simply take your figure
> object/reference and Pickle it (see
> http://docs.python.org/lib/module-pickle.html)?
> 
Won't work. Pickling only works for objects that have been designed for 
it. Such design is not trivial for extension code, and has not been 
done for mpl.
Eric

On 8/23/07, Alex Pounds <al...@al...> wrote:
> On Thu, August 23, 2007 5:33 pm, David Tremouilles wrote:
> > I would like to save a matplotlib figure (data, title and axes label,
> > plot properties, ...) to load it later on for modification. Something
> > like figure.savelall("file.matplot") and later on do a
> > figure.loadall("file.matplot") using an empty figure.
> I am but a humble newbie, but why not simply take your figure
> object/reference and Pickle it (see
> http://docs.python.org/lib/module-pickle.html)?
Reasonable request, reasonable solution, but alas neither will work.
The mpl extension code doesn't support pickling.
JDH

On Thu, August 23, 2007 5:33 pm, David Tremouilles wrote:
> I would like to save a matplotlib figure (data, title and axes label,
> plot properties, ...) to load it later on for modification. Something
> like figure.savelall("file.matplot") and later on do a
> figure.loadall("file.matplot") using an empty figure.
I am but a humble newbie, but why not simply take your figure
object/reference and Pickle it (see
http://docs.python.org/lib/module-pickle.html)?
-- 
Alex Pounds (Creature) .~. http://www.alexpounds.com/
 /V\ http://www.ethicsgirls.com/
 // \\
"Variables won't; Constants aren't" /( )\
 ^`~'^

Hello,
 I would like to save a matplotlib figure (data, title and axes label,
plot properties, ...) to load it later on for modification. Something
like figure.savelall("file.matplot") and later on do a
figure.loadall("file.matplot") using an empty figure.
Did somebody already implement such a functionality?
If yes Is it available somewhere or are you eager to share it?
Thanks,
David

Hi
thanks a lot for this feedback!
Your example is quite nice indeed. However there is something I may not
have fully understand.
If I use the example you sketch, I of course need to call the displayer
class (right?), by doing something like:
test = displayer()
However, then I hit the same problem again: I would need to define ALL
the commands I wish to go through WITHIN the displayer class (and more
precisely into the "show_next" function), because any command put after
the "test = displayer()" would be executed anyway without waiting that I
finally hit the right mouse button.
Or is there something I didn't catch which would allow me to go around this?
(what my program is supposed to do at the end is to go through a series
of (3xdataframes), and for each dataframe in turn, use the "offset"
trick, then reinitialise everything and start with the next series...
This seems to imply that I need to specify the full set of commands
within the displayer class show_next function)
thanks again
Eric

"Lee, Young-Jin" <yo...@uc...> writes:
> Then, I realized because each bar is so narrow I can't see the color of
> the bars but only outside lines (I see the colors by zooming it), which
> I couldn't find a way to change the color. My question is, is there any
> way either 1) to get rid of the outside lines or 2) to change the color
> of the lines? Thanks much in advance!
To get rid of the lines, set the linewidth property of the bars to 0; 
to change their color, set the edgecolor property. For example, using
ipython -pylab:
In [31]: a=bar([1,2,3,4],[3,1,4,1],lw=0)
In [32]: setp(a[1], lw=10, ec='red')
Out[32]: [None, None]
Here I used the abbreviations lw and ec for linewidth and edgecolor. 
The first command creates a bar chart where all bars have line width 
zero, the second modifies one of the bars to have very thick red edges. 
You can experiment with the properties using the pylab commands getp 
and setp.
-- 
Jouni K. Seppänen
http://www.iki.fi/jks

Lee, Young-Jin wrote:
> Hey guys,
> 
> 
> 
> I’m a new guy in here and amazed by the capability Matplotlib has. I 
> have a question for you, which might be a result of my ignorance or the 
> limitation of the current Matplotlib. I’m trying to make a bar chart 
> with hundreds of bars at different x positions with their own y values 
> (so called mass spectra) and would like to have different colors for 
> some of them, but the bar colors were never changed to what I intended. 
> Then, I realized because each bar is so narrow I can’t see the color of 
> the bars but only outside lines (I see the colors by zooming it), which 
> I couldn’t find a way to change the color. My question is, is there any 
> way either 1) to get rid of the outside lines or 2) to change the color 
> of the lines? Thanks much in advance!
For (1), use the linewidth=0 kwarg, e.g.:
barh(pos,val, align='center', linewidth=0)
Eric
> 
> 
> 
> Young Jin
> 
> 
> 
> 
> ------------------------------------------------------------------------
> 
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems? Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users

Hey guys,
=20
I'm a new guy in here and amazed by the capability Matplotlib has. I
have a question for you, which might be a result of my ignorance or the
limitation of the current Matplotlib. I'm trying to make a bar chart
with hundreds of bars at different x positions with their own y values
(so called mass spectra) and would like to have different colors for
some of them, but the bar colors were never changed to what I intended.
Then, I realized because each bar is so narrow I can't see the color of
the bars but only outside lines (I see the colors by zooming it), which
I couldn't find a way to change the color. My question is, is there any
way either 1) to get rid of the outside lines or 2) to change the color
of the lines? Thanks much in advance!
=20
Young Jin
=20

On 8/22/07, Tom Vaughan <to...@cr...> wrote:
> Why on the YellowDog 3 system would the x-axis show up as 0 - 2.5, and
> on the Ubuntu Feisty system would the x-axis show up as 2.2 - 2.4? I
> am attempting to resolve an autoscale problem elsewhere, and I must of
> screwed something up when I built matplotlib. But what?
The only explanation that makes sense to me is that you are picking up
different versions of mpl. Did you ever install from svn on any
system? You can print
>>> import matplotlib
>>> print matplotlib.__version__
but that doesn't always help, because frequently different svn
versions will print the same version number. We should adopt the
numpy and scipy system of tagging the version w/ the svn revision
number....
JDH

Hi,
I have matplotlib 0.90.1 on YellowDog 3 PPC with Python 2.5 and all
the support libraries built by hand, and matplotlib-0.90.1 on Ubuntu
Feisty x86 via `aptitude install`. And let's say I have:
import pylab
pylab.plot([2.2, 2.3, 2.4], [0, 5, 1])
pylab.show()
Why on the YellowDog 3 system would the x-axis show up as 0 - 2.5, and
on the Ubuntu Feisty system would the x-axis show up as 2.2 - 2.4? I
am attempting to resolve an autoscale problem elsewhere, and I must of
screwed something up when I built matplotlib. But what?
Thanks.
-Tom