matplotlib-users Mailing List for matplotlib (Page 4)

I tried with what you suggested to make an Arrow class. To begin with, I 
only put an Line2D instance. I searched for table stuff in axes.py, 
matlab.py to make the arrow importable from matplotlib.matlab. Then I 
also try a very very simple demo and I expect to see a simple line. 
However, I can not see it. Could someone tell me what is the problem. 
Here is my very very rudimental codes.
-----------------------------------------------------------------
arrow.py
from artist import Artist
from lines import Line2D
from patches import RegularPolygon
class Arrow(Artist):
	"""
	An arrow with an triangular head .
	"""
	def __init__(self, xdata=None, ydata=None, *args, **kwargs):
		
		Artist.__init__(self)
		print xdata, ydata
		self._stem = Line2D(xdata, ydata, *args, **kwargs)
		
	def draw(self, renderer):
		self._stem.draw(renderer)
------------------------------------------------------------
in file axes.py
 in function cla add:
 self.arrows = []
---------------------------
 def add_arrow(self, a):
 'Add an arrow instance to the list of axes arrows'
 self._set_artist_props(a)
 self.arrows.append(a)
 def arrow(self, x, y, *args, **kwargs):
 a = Arrow(x,y, *args, **kwargs)
 self.add_arrow(a)
 return a
-------------------------------------------------------------
in file matlab.py
	add two tring for importing arrow
-------------------------------------------------------------
arrow_demo.py
from matplotlib.matlab import *
x = [0,1]
y = [0,1]
arrow(x,y, color='b',linestyle='-')
show()
-------------------------------------------------------------
Best regards,
Chris
John Hunter wrote:
> I recommend creating an arrow class, derived from matplotlib.artist.Artist, that
> contains a matplotlib.lines.Line2D for the arrow stem and a
> matplotlib.patches.RegularPolygon with numVertices=3 for the arrow
> head. You can control the rotation of the arrowhead with the
> orientation argument. 
> 
> Once you have this class so defined, you can add it instances of it to
> the axes with ax.add_artist(arrow).
> 
> I'll be happy to help out with a prototype if you have trouble. Take
> a look at matplotlib.table.Cell, which John Gill wrote to support
> tables. You can use this as a simple model for how to write new
> artists (things that draw into a figure) composed of other artists.
> 
> It would be nice to have a fancy arrow class, that supported text
> labeling, at the base, along the stem and at the arrowhead. You could
> also consider a more sophisticated polygon other than a triangle for
> the arrowhead.
> 
> Finally, if you needed to draw *a lot of arrows*, order of a thousand
> or more (eg for direction fields), a
> matplotlib.collections.PolygonCollection would be the way to go for
> efficiency.
> 
> JDH
> 
> 
> -------------------------------------------------------
> This SF.Net email is sponsored by:
> Sybase ASE Linux Express Edition - download now for FREE
> LinuxWorld Reader's Choice Award Winner for best database on Linux.
> http://ads.osdn.com/?ad_id=5588&alloc_id=12065&op=click

>>>>> "matthew" == matthew arnison <ma...@ca...> writes:
 matthew> Oh dear. I'm going to take another u-turn, and say I hit
 matthew> this IMAGE_FORMAT attribute glitch again.
Try running your script with --verbose-helpful or --verbose-debug and
report the output. That way we can see what is happening behind the
scenes.
 matthew> To atone for my reversals, I have isolated a test case,
 matthew> and I attach sample code. It seems to be triggered by
 matthew> importing matplotlib.matlab in one module, and importing
 matthew> matplotlib backend stuff directly in another module.
 matthew> Running frog.py gives:
 matthew> line 1423, in __init__ self.IMAGE_FORMAT =
 matthew> matplotlib.backends.backend_mod.IMAGE_FORMAT
 matthew> AttributeError: 'module' object has no attribute
 matthew> 'IMAGE_FORMAT'
Fernando added the backend_mod to matplotlib.backends.__init__.py --
perhaps he has some insight into what is going on.
 matthew> As commented in the code, changing the order of the
 matthew> import statements in frog.py avoids the bug. Or using the
 matthew> workaround I mentioned below.
 matthew> Hmmm. Now I remember an email from John Hunter saying
 matthew> that pythonic matplotlib should not be mixed with the
 matthew> matlab interface. Maybe this glitch is an artefact of
 matthew> that. It does mean however that all my modules have to
 matthew> use one API or the other.
Yes, this is basically undefined. When using the API, you control
figure canvases, windows, backends, etc, independently. When you
import matplotlib.matlab, it parses your rc file (or not finding it
falls back on a default) and may try and load a different backend.
Since IMAGE_FORMAT is only used in some backends, my guess is you are
seeing a backend conflict. Running --verbose-helpful should give you a
clue about which backends matplotlib is loading.
Note there are scant few features in the matlab interface that you
can't access directly from the API. There is no compelling reason to
mix them, save laziness, and as you are finding, it doesn't really
save you any time. If you want to use something from the matlab
interface and aren't sure how to do it from the API, open up matlab.py
and take a look at how that function does it. A large number if not
the majority of matlab interface functions simply forward their calls
on to the current axes.
JDH

Oh dear. I'm going to take another u-turn, and say I hit this
IMAGE_FORMAT attribute glitch again.
To atone for my reversals, I have isolated a test case, and I attach
sample code. It seems to be triggered by importing matplotlib.matlab in
one module, and importing matplotlib backend stuff directly in another
module.
Running frog.py gives:
Traceback (most recent call last):
 File "frog.py", line 4, in ?
 embedding_in_gtk2_mra.plotme()
 File "M:\home\My Documents\My
Downloads\matplotlib-0.64\matplotlib-0.64\examples\embedding_in_gtk2_mra.py", 
line 39, in plotme
 toolbar = NavigationToolbar(canvas, win)
 File
"C:\Python23\lib\site-packages\matplotlib\backends\backend_gtk.py", line
963, in __init__
 NavigationToolbar2.__init__(self, canvas)
 File "C:\Python23\Lib\site-packages\matplotlib\backend_bases.py",
line 786, in __init__
 self._init_toolbar()
 File
"C:\Python23\lib\site-packages\matplotlib\backends\backend_gtk.py", line
1028, in _init_toolbar
 self._init_toolbar2_4()
 File
"C:\Python23\lib\site-packages\matplotlib\backends\backend_gtk.py", line
1091, in _init_toolbar2_4
 parent=self.win,)
 File
"C:\Python23\lib\site-packages\matplotlib\backends\backend_gtk.py", line
1423, in __init__
 self.IMAGE_FORMAT =
matplotlib.backends.backend_mod.IMAGE_FORMAT
AttributeError: 'module' object has no attribute 'IMAGE_FORMAT'
As commented in the code, changing the order of the import statements in
frog.py avoids the bug. Or using the workaround I mentioned below.
Hmmm. Now I remember an email from John Hunter saying that pythonic
matplotlib should not be mixed with the matlab interface. Maybe this
glitch is an artefact of that. It does mean however that all my modules
have to use one API or the other.
Cheers,
Matthew.
matthew arnison wrote:
> 2. I was getting errors that the 
> matplotlib.backends.backend_mod.IMAGE_FORMAT attribute was not found, 
> during toolbar initialization. I put in a workaround.
> 
> works with matplotlib 0.63:
> 
> import matplotlib
> matplotlib.use('GTK')
> 
> from matplotlib.backends.backend_gtk import FigureCanvasGTK
> from matplotlib.backends.backend_ps import FigureCanvasPS
> from matplotlib.backends.backend_gtk import NavigationToolbar2GTK as 
> NavigationToolbar
> 
> using matplotlib 0.64:
> 
> import matplotlib
> matplotlib.use('GTK')
> from matplotlib.backends import backend_gtk
> matplotlib.backends.backend_mod = backend_gtk
> 
> from matplotlib.backends.backend_gtk import FigureCanvasGTK
> from matplotlib.backends.backend_ps import FigureCanvasPS
> from matplotlib.backends.backend_gtk import NavigationToolbar2GTK as 
> NavigationToolbar
> 
> This style was cribbed from matplotlib examples and / or emails on this 
> list.
> 
> Cheers,
> Matthew.

John Hunter wrote:
>>>>>>"Chris" == Chris Barker <Chr...@no...> writes:
>>>>>> 
>>>>>>
>
>
> Chris> no, I was a bit wrong. Python functions always return one
> Chris> object, and when it appears that you are returning multiple
> Chris> objects, you are really returning a single tuple with
> Chris> multiple objects in it. Have I got it right this time?
>
>Sounds right to me. Your answer does point to the danger of using
>nargout in python
>
> ret = somefunc()
> i,j = ret 
>
>If somefunc is relying on nargout, it will botch it.
>
>I think the only sane use for nargout in python is in auto-conversion
>scripts, and then with appropriate warnings. 
>
>Thanks said, I would still like to have it, for that reason.
> 
>
Matlab also returns one object- the varargout cell array which is 
similar to Python's list or tuple. You write a function, and pack 
varargout with nargout results: [a,b]=matlabfun().

Well it works now.
For other reasons I downgraded to 0.63 and upgraded again to 0.64. As part
of this I found I had to manually wipe not only
Python23/Lib/site-packagaes/matplotlib but also Python23/share/matplotlib
to avoid errors (e.g. an ImportError: cannot import artist from Artist).
But now I don't need that workaround to avoid the IMAGE_FORMAT error.
examples/embedding_in_gtk2.py works fine too, after patching in the
toolbar = NavigationToolbar(canvas, win)
API change.
I'm sorry for the confusion.
Cheers,
Matthew.
On 2004年11月10日, Steve Chaplin wrote:
> On Tue, 2004年11月09日 at 12:24, matthew arnison wrote:
> > 2. I was getting errors that the
> > matplotlib.backends.backend_mod.IMAGE_FORMAT attribute was not
> > found, during toolbar initialization. I put in a workaround.
>
> Is this happening when using the classes directly rather than using the
> matlab interface? Are you doing something similar to the example
> "embedding_in_gtk2.py" - that works OK for me.
> Could you provide a minimal example to demonstrate this.
>
> Steve

>>>>> "Chris" == Chris Barker <Chr...@no...> writes:
 Chris> no, I was a bit wrong. Python functions always return one
 Chris> object, and when it appears that you are returning multiple
 Chris> objects, you are really returning a single tuple with
 Chris> multiple objects in it. Have I got it right this time?
Sounds right to me. Your answer does point to the danger of using
nargout in python
 ret = somefunc()
 i,j = ret 
If somefunc is relying on nargout, it will botch it.
I think the only sane use for nargout in python is in auto-conversion
scripts, and then with appropriate warnings. 
Thanks said, I would still like to have it, for that reason.
JDH

John Hunter wrote:
> What do you mean that python functions always return a tuple? How
> about functions that return an int, or a string, or whatever? 
> 
>>>>def func(): return 1
>>>>type(func())
> 
> <type 'int'>
> 
> Do you mean that python functions that return tuples always return
> tuples <wink> ?
no, I was a bit wrong. Python functions always return one object, and 
when it appears that you are returning multiple objects, you are really 
returning a single tuple with multiple objects in it. Have I got it 
right this time?
-Chris
-- 
Christopher Barker, Ph.D.
Oceanographer
 		
NOAA/OR&R/HAZMAT (206) 526-6959 voice
7600 Sand Point Way NE (206) 526-6329 fax
Seattle, WA 98115 (206) 526-6317 main reception
Chr...@no...

>>>>> "Chris" == Chris Barker <Chr...@no...> writes:
 Chris> Darren Dale wrote:
 >> >I guess there is no way in Python of emulating >Matlab"s
 >> detection of the number of output arguments. I just got a
 >> response from c.l.p. Somebody remembered seeing this at ASPN:
 >> http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/284742
 >> expecting() is the workhorse, equivalent to Matlab's nargout:
 Chris> Very cool. but I'd caution against using it. I'd much
 Chris> rather see matplotlib be pythonesque than an exact
 Chris> duplicate of MATLAB. This is NOT pythonesque!
I tend to agree with the caution against using it. But it would be
useful in some contexts, like converting existing matlab m-files to
python/numeric/numarray, the desire for which has occurred in some
contexts. Last time the discussion came up, the lack of nargout was
raised as a problem for any converter code.
 Chris> Precisely speaking, python functions ALWAYS return just one
 Chris> object: A tuple. That tuple can contain any number of other
 Chris> objects, and sequence unpacking means it can look like
 Chris> you're returning multiple values, but you're not
 Chris> really. i.e.
What do you mean that python functions always return a tuple? How
about functions that return an int, or a string, or whatever? 
>>> def func(): return 1
>>> type(func())
<type 'int'>
Do you mean that python functions that return tuples always return
tuples <wink> ?
JDH

Darren Dale wrote:
> >I guess there is no way in Python of emulating
> >Matlab"s detection of the number of output arguments.
> 
> I just got a response from c.l.p. Somebody remembered seeing this at ASPN:
> http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/284742
> 
> expecting() is the workhorse, equivalent to Matlab's nargout:
Very cool. but I'd caution against using it. I'd much rather see 
matplotlib be pythonesque than an exact duplicate of MATLAB. This is NOT 
pythonesque!
Precisely speaking, python functions ALWAYS return just one object: A 
tuple. That tuple can contain any number of other objects, and sequence 
unpacking means it can look like you're returning multiple values, but 
you're not really. i.e.
def test():
	return (1,2,3) # same as return 1,2,3
# now call it:
a,b,c = test()
(a,b,c) = test()
x = test(); a,b,c = x
x = test(); a = x[0]; b = x[1]; c = x[2]
# Are all equivalent
if one uses the last two forms, expecting() will break.
-Chris
-- 
Christopher Barker, Ph.D.
Oceanographer
 		
NOAA/OR&R/HAZMAT (206) 526-6959 voice
7600 Sand Point Way NE (206) 526-6329 fax
Seattle, WA 98115 (206) 526-6317 main reception
Chr...@no...

Hi John,
> >> I guess there is no way in Python of emulating Matlab"s
> >> detection of the number of output arguments.
>
> Darren> I just got a response from c.l.p. Somebody remembered
> Darren> seeing this at ASPN:
> Darren> http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/284742
>
> Darren> expecting() is the workhorse, equivalent to Matlab's
> Darren> nargout:
>
> Darren> import inspect,dis
>
> Hi Darren,
>
> Wow, I didn't know this was possible in python. Does it work under
> python2.2?
The ASPN page says it has been tested on 2.3.3. I dont have a 2.2 installation 
handy to check it.
>
> Perhaps you would like to write up nargin and nargout function with
> some doc strings and send them my way? I could add them to the matlab
> interface. But we need to make sure they are 2.2 compliant.
I will give it a shot in my free time, but without getting into it, my next 
month is pretty full.
>
> As an aside, do we need nargout to make "find" work like matlab's?
> Isn't it enough just to check the shape of the input array and
> processing it one way for 1D arrays and another way for 2D arrays?
>
The problem is that mlab.find() is currently a thin wrapper around a numeric 
or numarray method, which only works for 1D arrays. ravelling the arrays 
passed to find would make it easy to continue using the method called by 
find(), but I had trouble figuring out how to process the 1xM results of that 
method back into an NxM or MxN array that could be used to index an N-D 
array. 
It would be nice to be able to address Numeric and numarray with a single 
index. Matlab does this. For example, if a=array([[1,2],[3,4]]), a[0] would 
be 1, a[1] would be 3 (Matlab's convention, again if memory serves.) 
-- 
Darren

>>>>> "Darren" == Darren Dale <dd...@co...> writes:
 >> I guess there is no way in Python of emulating Matlab"s
 >> detection of the number of output arguments.
 Darren> I just got a response from c.l.p. Somebody remembered
 Darren> seeing this at ASPN:
 Darren> http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/284742
 Darren> expecting() is the workhorse, equivalent to Matlab's
 Darren> nargout:
 Darren> import inspect,dis
Hi Darren,
Wow, I didn't know this was possible in python. Does it work under
python2.2?
Perhaps you would like to write up nargin and nargout function with
some doc strings and send them my way? I could add them to the matlab
interface. But we need to make sure they are 2.2 compliant.
As an aside, do we need nargout to make "find" work like matlab's?
Isn't it enough just to check the shape of the input array and
processing it one way for 1D arrays and another way for 2D arrays?
 
Cheers,
JDH

>>>>> "Jos=E9" =3D=3D Jos=E9 Alexandre Nalon <na...@te...> writes:
 Jos=E9> Hello, I think I've found a bug in mathtext - sorry if this
 Jos=E9> appeared before, I couldn't find it in the list archives.
 Jos=E9> When I try:
 Jos=E9> xlabel(r"$-(\Omega_a^' + \Omega_a)$")
 Jos=E9> I don't get what I expected. The label shows -\Omega_a and
 Jos=E9> stops there. Further tests showed that, whenever I try a
 Jos=E9> single quote in a mathtext string, the text is not rendered
 Jos=E9> from the quote on.
 Jos=E9> This might not be a bug, I might be doing something
 Jos=E9> wrong. If this is the case, please tell me how to do it
 Jos=E9> right.
I don't believe your use of ' is valid TeX. Try
Omega_a^\prime
 Jos=E9> Thanks in advance.
Sure thing,
JDH

> xlabel(r"$-(\Omega_a^' + \Omega_a)$")
>
> I don't get what I expected. The label shows -\Omega_a and stops
> there. Further tests showed that, whenever I try a single quote
> in a mathtext string, the text is not rendered from the quote on.
>
> This might not be a bug, I might be doing something wrong. If
> this is the case, please tell me how to do it right.
>
try replacing ^' with ^\prime
Darren

Hello,
I think I've found a bug in mathtext - sorry if this appeared
before, I couldn't find it in the list archives.
When I try:
xlabel(r"$-(\Omega_a^' + \Omega_a)$")
I don't get what I expected. The label shows -\Omega_a and stops
there. Further tests showed that, whenever I try a single quote
in a mathtext string, the text is not rendered from the quote on.
This might not be a bug, I might be doing something wrong. If
this is the case, please tell me how to do it right.
Thanks in advance.
---
José Alexandre Nalon
na...@te...

 >I guess there is no way in Python of emulating
 >Matlab"s detection of the number of output arguments.
I just got a response from c.l.p. Somebody remembered seeing this at ASPN:
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/284742
expecting() is the workhorse, equivalent to Matlab's nargout:
import inspect,dis
def expecting():
 """Return how many values the caller is expecting"""
 f = inspect.currentframe()
 f = f.f_back.f_back
 c = f.f_code
 i = f.f_lasti
 bytecode = c.co_code
 instruction = ord(bytecode[i+3])
 if instruction == dis.opmap['UNPACK_SEQUENCE']:
 howmany = ord(bytecode[i+4])
 return howmany
 elif instruction == dis.opmap['POP_TOP']:
 return 0
 return 1
def cleverfunc():
 howmany = expecting()
 if howmany == 0:
 print "return value discarded"
 if howmany == 2:
 return 1,2
 elif howmany == 3:
 return 1,2,3
 return 1
def test():
 cleverfunc()
 x = cleverfunc()
 print x
 x,y = cleverfunc()
 print x,y
 x,y,z = cleverfunc()
 print x,y,z
test()

Hi Jouni,
Jouni K Sepp=E4nen wrote:
>On 2004年11月14日 18:08:59 +0200, Jouni K Sepp=E4nen
><jou...@gm...> wrote:
> =20
>
>>Here's what I'm using to emulate Matlab's find; it only seems to work
>>with Numeric, not numarray
>> =20
>>
>
>Oops - actually it seems that after
>
>from matplotlib.numerix import ravel, indices, compress
>
>the function works whether numerix is using numarray or Numeric.
>
>Making a special case of single-dimensional inputs is not very
>elegant, but doing otherwise would break compatibility with the
>existing mlab.find; and I guess there is no way in Python of emulating
>Matlab's detection of the number of output arguments.
> =20
>
I looked at this a while back, and came to the same conclusion. Thats an=20
interesting question, can Python determine the number of output=20
arguments? I dont know of a convenient function call, but it seems like=20
that information must exist somewhere. I'll ask at c.l.p.
Darren

On 2004年11月14日 18:08:59 +0200, Jouni K Sepp=E4nen
<jou...@gm...> wrote:
>
> Here's what I'm using to emulate Matlab's find; it only seems to work
> with Numeric, not numarray
Oops - actually it seems that after
from matplotlib.numerix import ravel, indices, compress
the function works whether numerix is using numarray or Numeric.
Making a special case of single-dimensional inputs is not very
elegant, but doing otherwise would break compatibility with the
existing mlab.find; and I guess there is no way in Python of emulating
Matlab's detection of the number of output arguments.
--=20
Jouni K Sepp=E4nen
http://www.iki.fi/jks

Hi,
In Matlab, the command
 [i,j] =3D find(mat >=3D 3)
causes i and j to hold the indices where the condition holds. (If
there is only one output argument, it will hold indices to the
flattened version of the condition.) Matplotlib's mlab.find() seems to
work for one-dimensional arrays only.
Here's what I'm using to emulate Matlab's find; it only seems to work
with Numeric, not numarray, and I have no idea whether this is an
efficient way to achieve the goal. I was going to suggest that the
utility be included in matplotlib, but perhaps it should then be
generalized to work with numarray as well. I wonder if anyone has any
ideas on how to do this? I'm a newcomer to matplotlib (and Numeric,
etc.), so please do point out if there is a simpler way to achieve the
effect of Matlab's find.
def find(condition):
 """
 Return the indices where condition is true.
 For arrays of N>=3D2 dimensions, returns a tuple T of N arrays
 such that the condition is true at indices (T[0][i],...,T[N-1][i]).
 """
 sh =3D condition.shape
 if len(sh) =3D=3D 1:
 return nonzero(condition)
 idx =3D indices(sh)
 cond =3D ravel(condition)
 return tuple([compress(cond, ravel(idx[i]))=20
 for i in range(len(sh))])
--=20
Jouni K Sepp=E4nen
http://www.iki.fi/jks

> To: Nils Wagner <nw...@me...>
> Cc: SciPy Users List <sci...@sc...>,
> 	mat...@li...
> Subject: Re: [Matplotlib-users] Visualizing Sparsity Pattern of matrices
> From: John Hunter <jdh...@ac...>
> Date: 2004年11月11日 09:16:03 -0600
> 
> 
>>>>>>"Nils" == Nils Wagner <nw...@me...> writes:
> 
> 
> Nils> Hi all, Structure plots provide a quick visual check on the
> Nils> sparsity pattern of the matrix. A structure plot is a
> Nils> rectangular array of dots; a dot is black if the
> Nils> corresponding matrix element is nonzero otherwise it is
> Nils> white.
> 
> Nils> Is it possible to generate such plots with scipy or should
> Nils> we switch over to matplotlib ?
> 
> Here's another implementation that uses images - likely to be much
> faster for very large matrices.
Hi,
As part of a programming environment for optimization in Python (soon to 
be released hopefully), I use Matplotlib for the graphics. I created 
several functions imitating Matlab's spy() using scatter(). My sparse 
matrices are represented in linked-list, compressed column or compressed 
row storage using the PySparse implementation
	http://people.web.psi.ch/geus/pyfemax/pysparse.html
Using scatter, I can plot the sparsity pattern of matrices with several 
thousands of lines and columns in a blink on my 1.7GHz P4 laptop. Using 
color maps, you can even color your dots according to the magnitude of 
the element they represent (a 2-dimensional "city plot" of a matrix).
Dominique

>>>>> "Dimitri" == Dimitri D'Or <dim...@fs...> writes:
 Dimitri> Hello, I would like to know if there is a mean for
 Dimitri> testing on the hold status of a figure, i.e. to know if
 Dimitri> hold is 'on' or 'off' ?
 Dimitri> In fact, I use frequently the ISHOLD function in Matlab
 Dimitri> and I can't find a similar one in Matplotlib.
A sin of omission. I just added it to CVS. If you don't have CVS
access, in the meantime, you can either use the ax._ishold variable to
inspect the axes hold status, or add the following
to matplotlib.axes.Axes:
 def ishold(self):
 'return the HOLD status of the axes'
 return self._hold
and to matplotlib.matlab
 def ishold(b=None):
 """
 Return the hold status of the current axes
 """
 return gca().ishold() 
Should cure what ails ya ...
JDH

>>>>> "Shin" == Shin <sd...@em...> writes:
 Shin> Currently, figure() is the same as figure(1). But, I think
 Shin> a better behavior of figure is: figure() is the same as
 Shin> figure(n+1) where n is the maximum handle number of opened
 Shin> figures. So, figure() always creates a new figure. This is
 Shin> exactly MATLAB is doing. Any comment?
Looks like a bug - thanks.
Is anybody relying on the fact the figure() currently returns the
current figure if it exists? This is basically the role of gcf,
anyway, which creates a figure none exists and returns it, otherwise
it returns the current figure.
So figure should auto-increment, as you suggest.
JDH

>>>>> "Shin" == Shin <sd...@em...> writes:
 Shin> Thanks. Let me ask another question. How can I get the
 Shin> current mode? I like to recover mode after drawing
 Shin> everything in non-interactive mode. From help document,
 Shin> interactive() seems not to give current mode.
>>> from matplotlib import interactive, is_interactive
>>> print is_interactive()
False
Sorry that these features aren't documented :-(
By the way, ipython already has all of this built-in. In the pylab
mode you start in interactive mode. But you can "run" a code snippent
using the run command, which turns off interactive mode for the
duration of the run, restoring the original interactive state when the
run finishes.
JDH

Hello,
I would like to know if there is a mean for testing on the hold status of a 
figure, i.e. to know if hold is 'on' or 'off' ?
In fact, I use frequently the ISHOLD function in Matlab and I can't find a 
similar one in Matplotlib.
Thank you,
Dimitri

Currently, figure() is the same as figure(1).
But, I think a better behavior of figure is:
figure() is the same as figure(n+1) where n is the maximum handle number 
of opened figures. So, figure() always creates a new figure.
This is exactly MATLAB is doing.
Any comment?
Daehyok Shin
UNC-CH

Thanks. Let me ask another question.
How can I get the current mode?
I like to recover mode after drawing everything in non-interactive mode.
 From help document, interactive() seems not to give current mode.
Daehyok Shin
John Hunter wrote:
> 
> from matplotlib import interactive
> from matplotlib.matlab import *
> 
> plot([1,2,3])
> interactive(False) # turn off interactive mode
> xlabel('hi mom')
> ylabel('bye')
> title('all done')
> interactive(False) # turn it back on
> draw() # draw the canvas
> 
> JDH
> 
> 
> 
> 
> 
> 
> 
> Shin> ------------------------------------------------------- This
> Shin> SF.Net email is sponsored by: Sybase ASE Linux Express
> Shin> Edition - download now for FREE LinuxWorld Reader's Choice
> Shin> Award Winner for best database on Linux.
> Shin> http://ads.osdn.com/?ad_id=5588&alloc_id=12065&op=click
> Shin> _______________________________________________
> Shin> Matplotlib-users mailing list
> Shin> Mat...@li...
> Shin> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>