matplotlib-users Mailing List for matplotlib

Hi,

I'm trying to write a very simple GUI using matplotlib and have  
gotten stuck. Hopefully someone out there has done something similar  
and can point me on my way.

First, I should mention that the examples provided with matplotlib  
weren't immediately helpful to me, because when I try to run various  
demos (like pick_event_demo or object_picker) it fails b/c I'm  
relying on (and have to rely on) TkAgg. Sadly, I'm too new to  
understand what I would need to do to get those demos working. So I  
found someone processing mouseclicks using a Mac online and started  
there.

I ended up with something like this:

   from pylab import *
   class gui :
     	def __init__(self) :
	    	self.f = figure()
		self.data = None  # valid mouse click hasn't yet happened
	        def clicker(event):
			self.data = event.xdata
         	self.f.canvas.mpl_connect("button_press_event",clicker)

	def getNextValidClick(self) :
	        (data, self.data) = (None, None)
	        while True :
             		print "Waiting for valid mouse click..."
	        	while self.data == None :
                 		pass # keep polling
			if 1 <= self.data <= 3 :
				# consider this a valid next mouse click
				(data, self.data) = (self.data, None)
       				break
		return data

With which I tried:

g = gui()
x = g.getNextValidClick()

but the latter line caused me to experience the spinning wheel of  
dead that we mac users so enjoy.

I have the feeling I need to explicitly yield or some such in the  
poll loop, but I don't know how to do that.

Advice greatly appreciated, both on the code I've provided, and on if  
there is a better way altogether to provide an app with data obtained  
via a matplotlib mouse click callback.

Thanks,

--b

Eric,

This is great; much thanks!

--b

On Mar 23, 2007, at 3:16 PM, Eric Firing wrote:

> belinda thom wrote:
>> Hi,
>> I'm wondering if there's an easy way to reverse an axis in a plot.
>
> Using methods:
>
> bottom, top = ax.get_ylim()
> ax.set_ylim(top, bottom)
>
> Or using pylab functions:
>
> bottom, top = ylim()
> ylim(top, bottom)
>
> Eric
>
>> For instance, suppose I wanted to create a plot that had its  
>> "origin"  in the upper left hand corner, so that x would range  
>> from, say 0 to 1  moving right, and y would range from, say 0 to  
>> 1, moving down.
>> Thanks!
>> --b
>> --------------------------------------------------------------------- 
>> ----
>> 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
>

belinda thom wrote:
> Hi,
> 
> I'm wondering if there's an easy way to reverse an axis in a plot.

Using methods:

bottom, top = ax.get_ylim()
ax.set_ylim(top, bottom)

Or using pylab functions:

bottom, top = ylim()
ylim(top, bottom)

Eric

> 
> For instance, suppose I wanted to create a plot that had its "origin"  
> in the upper left hand corner, so that x would range from, say 0 to 1  
> moving right, and y would range from, say 0 to 1, moving down.
> 
> Thanks!
> 
> --b
> 
> 
> -------------------------------------------------------------------------
> 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

Hi,

I'm wondering if there's an easy way to reverse an axis in a plot.

For instance, suppose I wanted to create a plot that had its "origin"  
in the upper left hand corner, so that x would range from, say 0 to 1  
moving right, and y would range from, say 0 to 1, moving down.

Thanks!

--b

Richard,

I have made the requested change to imshow, so it is consistent with the 
new matshow, and I think it makes much more sense this way--but note 
that it depends on your rc value for image.origin.  So, whenever you get 
mpl from svn, or the next release (whenever that occurs--not very soon, 
I suspect), I think you will find both matshow and imshow more to your 
liking.

I also changed the docstring explanation for the extent kwarg, noting 
that it gives (left, right, bottom, top) data limits of the axes.

More doc changes and other tweaks for this class of functions will be in 
order, when I get back to it.

Eric

Richard Brown wrote:
> On 22/03/07, Eric Firing <ef...@ha...> wrote:
>> Richard Brown wrote:
>> > Hi there,
>> >
>> > I'm pretty new to python; I'm in the process of switching from Matlab.
>> > I do quite a bit of image processing in my research, and while
>> > pylab/matplotlib seems to be a great plotting library, some of the
>> > quirks seem just a little bit frustrating - I'm hoping for some
>> > enlightenment :)
>> >
>> > When I use imshow or matshow to display an array, the points with
>> > index (m, n) are displayed with the pixels centred at (0.5 + m, 0.5 +
>> > n). Is there a setting somewhere to make it so that the centres of the
>> > pixels are at the index values rather than their bottom left corners?
>> > Or must I be always adding 0.5 to things to make them appear in the
>> > right places?
>>
>> Coincidentally, a few days ago I made this change for matshow; I had
>> made it in spy some time ago.  I have so far left imshow alone; isn't
>> its present behavior consistent with Matlab?  That is not necessarily a
>> good reason for leaving it the way it is, but it is reason for some
>> caution.  I suspect quite a few people may prefer it the way it is;
>> let's see who responds, and what opinions are voiced.
> 
> Thanks for your timely response. Let me give you a few examples to
> clarify the things which I think might be relevant issues to address.
> (numpy and pylab imported)
> 
> PRELIMINARIES
> # Create a 6x6 logical array with a 2x2 square near the to left
> xx = zeros((6, 6), dtype='Bool')
> xx[1:3, 1:3] = True
> 
> 
> EXAMPLE 1 - imshow
> Trying to plot a point which should appear on the square:
>>>> imshow(xx, interpolation='nearest')
>>>> plot([2],[2], 'y.', markersize=20)
> 
> The image looks correct, with the square in the top left, but the y
> axis is labelled backwards. Therefore when I try to plot a point in
> the middle of it, it misses altogether
> 
> EXAMPLE 2 - matshow (not your new version)
>>>> matshow(xx)
> So far so good - the y axis is the right way around
>>>> plot([2],[2], 'y.', markersize=20)
> Oops - the y axis flipped, there is a block of white at the top, and
> the image is now upside-down. The point has showed up in the right
> place w.r.t the image though.
> 
> EXAMPLE 3 - off by 0.5 problem - relevant to imshow too
>>>> matshow(xx)
> Let's say I want to compute the centroid of the square blob. IMO a
> natural way to do this is:
>>>> cen = mean(where(xx), 1)
>>>> plot([cen[0]], [cen[1]], 'y.')
> 
> This is off by 0.5 in both directions. This kind of thing is my
> argument for why the coordinate system should be aligned with the
> array indices.
> 
> Matlab behaviour:
> In Matlab, the pixels are centred on integer coordinates corresponding
> to their array index. Matlab indexing is ones based, so a 2x2 image
> will have axes limits of 0.5-2.5 in each direction, with the pixel
> centres at (1,1), (1,2) etc.
> imshow in Matlab plots the array with the (1,1) coordinate in the top
> left, and the y axis increasing from the top down (like what matshow
> does here)
> 
> cheers,
> 
> Richard

Creating a 'simplified' example (not really) to demonstrate the problem

Zoom in on one of the constant speed movements.(upper graph)

psd (lower graph) will still be showing spectrum of whole data file.

click 'n release  any mouse button in the upper graph, and only then 
will the lower graph redraw with the new limits.

zoom out, try again on other constant speed movement.

how to get lower graph to redraw on new limits after the zoom, without 
having to click the upper graph again?

Steve
> I have two plots.
>
> first one is velocity data from servo controller (freq)  - plant 
> reciprocates back and forth so we got turn data in there as well
> second one is psd  (power spectral density) so we can see where we got 
> resonances etc.
>
> When we zoom in on on section of first plot (say the forward movement), 
> I'd like to recalc the psd with only the data that's been zoomed in on.
>
> Everything kind of works except for somewhere to trigger from.
>
> I had thought of trying resize_event - however I cannot get this 
> working- see other post.
>
> I played with button_release_event to get the code basically working, 
> however that event occurs before the first graph gets resized, so the 
> region I am calculating the psd on is wrong, maybe because I am using
> xlim = myAxis.get_xlim()
> to find the limits of the first graph (which hasn't been re-drawn yet)
>
> Is there some way I can hook the re-calc/draw of psd to the zooming of 
> first graph?
>
> Previously with 2 plot commands, I have used subplot(212, sharex=p1), to 
> hook the two graphs together on the xaxis
> however as the second graph is a psd I don't know how to hook the psd 
> input data to the xaxis of the first graph.
>
>
> Thanks
> Ste
>   

On 22/03/07, Eric Firing <ef...@ha...> wrote:
> Richard Brown wrote:
> > Hi there,
> >
> > I'm pretty new to python; I'm in the process of switching from Matlab.
> > I do quite a bit of image processing in my research, and while
> > pylab/matplotlib seems to be a great plotting library, some of the
> > quirks seem just a little bit frustrating - I'm hoping for some
> > enlightenment :)
> >
> > When I use imshow or matshow to display an array, the points with
> > index (m, n) are displayed with the pixels centred at (0.5 + m, 0.5 +
> > n). Is there a setting somewhere to make it so that the centres of the
> > pixels are at the index values rather than their bottom left corners?
> > Or must I be always adding 0.5 to things to make them appear in the
> > right places?
>
> Coincidentally, a few days ago I made this change for matshow; I had
> made it in spy some time ago.  I have so far left imshow alone; isn't
> its present behavior consistent with Matlab?  That is not necessarily a
> good reason for leaving it the way it is, but it is reason for some
> caution.  I suspect quite a few people may prefer it the way it is;
> let's see who responds, and what opinions are voiced.

Thanks for your timely response. Let me give you a few examples to
clarify the things which I think might be relevant issues to address.
(numpy and pylab imported)

PRELIMINARIES
# Create a 6x6 logical array with a 2x2 square near the to left
xx = zeros((6, 6), dtype='Bool')
xx[1:3, 1:3] = True


EXAMPLE 1 - imshow
Trying to plot a point which should appear on the square:
>>> imshow(xx, interpolation='nearest')
>>> plot([2],[2], 'y.', markersize=20)

The image looks correct, with the square in the top left, but the y
axis is labelled backwards. Therefore when I try to plot a point in
the middle of it, it misses altogether

EXAMPLE 2 - matshow (not your new version)
>>> matshow(xx)
So far so good - the y axis is the right way around
>>> plot([2],[2], 'y.', markersize=20)
Oops - the y axis flipped, there is a block of white at the top, and
the image is now upside-down. The point has showed up in the right
place w.r.t the image though.

EXAMPLE 3 - off by 0.5 problem - relevant to imshow too
>>> matshow(xx)
Let's say I want to compute the centroid of the square blob. IMO a
natural way to do this is:
>>> cen = mean(where(xx), 1)
>>> plot([cen[0]], [cen[1]], 'y.')

This is off by 0.5 in both directions. This kind of thing is my
argument for why the coordinate system should be aligned with the
array indices.

Matlab behaviour:
In Matlab, the pixels are centred on integer coordinates corresponding
to their array index. Matlab indexing is ones based, so a 2x2 image
will have axes limits of 0.5-2.5 in each direction, with the pixel
centres at (1,1), (1,2) etc.
imshow in Matlab plots the array with the (1,1) coordinate in the top
left, and the y axis increasing from the top down (like what matshow
does here)

cheers,

Richard