matplotlib-users Mailing List for matplotlib

Hello,
I would like to plot the polarization state of a two-dimensional vector
field (linear, circular or generally elliptic), similarly to that seen on
this ZEMAX plot:
http://www.zemax.com/UserFiles/Image/UI/pol_pupil.gif
It looks like some kind of enhanced quiver plot: a small line with arrows at
both ends points out the local direction of linear polarization, while a
directed ellipse with a given orientation of its axes depicts local
elliptical polarization state (which becomes a circle for circular
polarization).
I am a novice matplotlib user, please give me some advice on how to start
with implementing such a plot (what to read, API examples to look at etc.)
Thanks,
Kornel JAHN

On Sat, Nov 13, 2010 at 7:58 PM, Michiel de Hoon <mjl...@ya...>wrote:
> Thanks for your reply.
>
> Regarding your first question, how exactly does it disrupt your workflow?
> Is it because the drawing takes too much time? Or because the focus switches
> from the terminal window to the figure window? Or because the figure takes
> up screen space?
>
>
It is partly because the focus switches from the terminal window to the
figure window (at least, at fiirst it does), but mostly because there isn't
enough screen real estate for both to co-exist. Therefore, I would be
alt-tabbing a lot if I am in interactive mode.
Anyway, I mostly work from the perspective of running scripts and larger
programs to generate publication quality figures and to perform data
analyses. My focus is not on messing around with my figures. The only time
I am doing that is when I am developing and testing a new script or feature,
in which case I might go into interactive mode to figure out what settings
and such make my figures look nice, or maybe not.
It is nice to have the option to suit my needs. More often than not, I am
in non-interactive mode. I see no reason to remove this feature as it puts
matplotlib ahead of other systems like Matlab. Choice is a good thing...
Ben Root

Thanks for your reply.
Regarding your first question, how exactly does it disrupt your workflow? Is it because the drawing 
takes too much time? Or because the focus switches from the terminal 
window to the figure window? Or because the figure takes up screen 
space?
Regarding the OP, my understanding is that the original issue is that with interactive=False, the MacOSX backend pops up a window while the other backends do not. It doesn't make a difference in running time, but anyway the different backends should behave the same way, so something needs to be done here.
--Michiel.
--- On Sat, 11/13/10, Benjamin Root <ben...@ou...> wrote:
I would like to cast a vote of support for the "interactive=False" setting. I often do work on my netbook, and having a figure window pop up while I am testing out some commands disrupts my workflow.
...
On the issue about the OP, I am a little bit confused as to what the exact issue is at hand. Is it that a figure window pops up in macosx backend regardless of the interactive setting? Or is it that non-macosx backends are not behaving the same way on a mac as they do on other systems? Is the issue that the plot window is blank on the macosx backend until the script finishes? I guess I am a little confused here.
 

Thanks for your reply.
--- On Sat, 11/13/10, Eric Firing <ef...@ha...> wrote:
> In the gtk backend, draw_idle calls gobject.idle_add 
> 
> Thus, "idle" means the gui event loop has no higher
> priority events. Is 
> this condition reached only at the end of the script?
With Python, there is only one thread (running both Python and the GUI). So the GUI event loop won't start until the end of the script, so there is no inadvertent redrawing regardless of interactive being True or False.
With ipython, I am not sure if they are using one thread, or one thread for Python and one thread for the GUI. But in practice, in ipython I also don't find any evidence of inadvertent redrawing. For example, this script:
import matplotlib
matplotlib.use("gtkagg")
import matplotlib.pyplot as plt
import numpy
x = numpy.random.random(400000)
y = x + numpy.random.random(400000)
plt.figure()
plt.hexbin(x, y, gridsize=300)
for i in range(1000):
 plt.xlabel('a label')
plt.show()
both with python and ipython take an equal amount of time regardless of interactive being True or False. If there were any redrawing after each call to plt.xlabel, this script would take forever.
> Reminder: the interactive setting controls
> draw_if_interactive, which is 
> what we are talking about here, but also whether or not
> show() blocks. 
> So we may not need draw_if_interactive, but unless we can
> dispense with 
> show entirely, we will still need an interactive setting.
If matplotlib were always interactive, then I don't see a good reason for non-blocking show().
> Returning to the issue raised by the OP, however, the
> question is 
> whether the present MacOSX behavior (windows pop up) or the
> non-MacOSX 
> behavior (they don't in non-interactive mode until/unless
> show() is 
> called) is what we really want. It seems to me that
> we should preserve 
> some way of getting this second behavior.
I agree. For example, if a user wants to make a figure for the sole purpose of creating a PNG file, there should be a way to do this without the figure popping up as a window.
--Michiel.
 

On Sat, Nov 13, 2010 at 12:06 PM, Eric Firing <ef...@ha...> wrote:
> On 11/13/2010 06:16 AM, Michiel de Hoon wrote:
> > --- On Sat, 11/13/10, John Hunter<jd...@gm...> wrote:
> >> Ie if we have a script like
> >>
> >> # some plotting commands
> >> ...
> >>
> >> # some expensive non GUI computation
> >> ...
> >>
> >> # some update to plot above
> >> ...
> >>
> >> Would we not run the risk that the GUI is idle in the non
> >> GUI computation and therefore trigger a draw in it's thread,
> >> and then do redraws again after the update code?
> >
> > In the MacOSX backend, everything is single-threaded, so this won't
> occur.
> >
> > I am not sufficiently familiar with the non-MacOSX backends to give a
> detailed answer, but with multiple threads the "idle" refers to the Python
> thread being idle rather than the GUI thread being idle. In other words,
> when there are no more Python commands left to be handled, the GUI thread is
> notified that it should start redrawing.
> >
>
> In the gtk backend, draw_idle calls gobject.idle_add
>
> http://www.pygtk.org/pygtk2reference/gobject-functions.html#function-gobject--idle-add
>
> Thus, "idle" means the gui event loop has no higher priority events. Is
> this condition reached only at the end of the script?
>
>
> >> Are you proposing that we can get rid of the interactive setting
> >> entirely, always call draw on pyplot commands, and let the
> >> idle handler save us from doing repeated draws?
>
> Reminder: the interactive setting controls draw_if_interactive, which is
> what we are talking about here, but also whether or not show() blocks.
> So we may not need draw_if_interactive, but unless we can dispense with
> show entirely, we will still need an interactive setting.
>
> Returning to the issue raised by the OP, however, the question is
> whether the present MacOSX behavior (windows pop up) or the non-MacOSX
> behavior (they don't in non-interactive mode until/unless show() is
> called) is what we really want. It seems to me that we should preserve
> some way of getting this second behavior.
>
> Eric
>
> >
> > Yes (I assume you mean to always call draw_idle on pyplot commands). If
> there are then still cases where we do get repeated draws, then that is a
> bug.
> >
> > Best,
> > --Michiel.
> >
>
>
I would like to cast a vote of support for the "interactive=False" setting.
I often do work on my netbook, and having a figure window pop up while I am
testing out some commands disrupts my workflow. When I want to see all my
figures, I will call show() when I am good and ready. And just as I often
do work on my netbook, I also do plenty of work on my workstation which
sports a large screen. In many cases on that machine, I would like to see
my figures while I am working on them, and having an easy option to turn
that on and off is valuable to me.
interactive : False was one of several reasons why I switched from Matlab to
matplotlib.
On the issue about the OP, I am a little bit confused as to what the exact
issue is at hand. Is it that a figure window pops up in macosx backend
regardless of the interactive setting? Or is it that non-macosx backends
are not behaving the same way on a mac as they do on other systems? Is the
issue that the plot window is blank on the macosx backend until the script
finishes? I guess I am a little confused here.
Ben Root