3

I am using ginput for a graphic selection of a few points along a time signal. Sometimes, when the signal is too dense it might be useful to zoom over an area before making the selection of points. My problem is that it seems that the zoom to rectangle option seems to be accounted for in ginput.

For instance, with this sample code:

from __future__ import print_function
from pylab import arange, plot, sin, ginput, show
import numpy as np

t = np.linspace(0,25,500)
plot(t, sin(t))
x = ginput(3)
print("clicked",x)
show()

If I zoom over a portion of the signal, the clicks made for the zoom area selection are accounted for in ginput... Is there a way to avoid this and make the zoom area selection independent from ginput ?

Alain
  • 381
  • 3
  • 19
  • Click on the zoom button (on the toolbar) again to deactivate the zoom tool and re-activate picking. (This is true for anything that uses pick events in matplotlib, not just `ginput`.) – Joe Kington Mar 19 '15 at 17:34
  • I am not sure to understand your comment. The thing is that picking seems to be always activated, which generates my problem. It is precisely because I cannot de-activate picking when I click on the zoom button in the tool bar that I asked this question. – Alain Mar 19 '15 at 18:05
  • Ah, sorry, I though you were asking the opposite. It turns out that `ginput` isn't implemented in the way I thought it was. – Joe Kington Mar 19 '15 at 19:03

3 Answers3

3

I was having the same issue and my fix was to write a function to zoom with the mouse wheel so I could zoom without clicking. I got the function from this page:

Matplotlib plot zooming with scroll wheel

and modified the function so that it was not zoomed past the original x and y limits:

def zoom_factory(ax, max_xlim, max_ylim, base_scale = 2.):
    def zoom_fun(event):
        # get the current x and y limits
        cur_xlim = ax.get_xlim()
        cur_ylim = ax.get_ylim()
        xdata = event.xdata # get event x location
        ydata = event.ydata # get event y location
        if event.button == 'up':
            # deal with zoom in
            scale_factor = 1/base_scale
            x_scale = scale_factor / 2
        elif event.button == 'down':
            # deal with zoom out
            scale_factor = base_scale
            x_scale = scale_factor * 2
        else:
            # deal with something that should never happen
            scale_factor = 1
            print(event.button)
        # set new limits
        new_width = (cur_xlim[1] - cur_xlim[0]) * x_scale
        new_height = (cur_ylim[1] - cur_ylim[0]) * scale_factor

        relx = (cur_xlim[1] - xdata) / (cur_xlim[1] - cur_xlim[0])
        rely = (cur_ylim[1] - ydata) / (cur_ylim[1] - cur_ylim[0])

        if xdata - new_width * (1 - relx) > max_xlim[0]:
            x_min = xdata - new_width * (1 - relx)
        else:
            x_min = max_xlim[0]
        if xdata + new_width * (relx) < max_xlim[1]:
            x_max = xdata + new_width * (relx)
        else:
            x_max = max_xlim[1]
        if ydata - new_height * (1 - rely) > max_ylim[0]:
            y_min = ydata - new_height * (1 - rely)
        else:
            y_min = max_ylim[0]
        if ydata + new_height * (rely) < max_ylim[1]:
            y_max = ydata + new_height * (rely)
        else:
            y_max = max_ylim[1]
        ax.set_xlim([x_min, x_max])
        ax.set_ylim([y_min, y_max])
        ax.figure.canvas.draw()

    fig = ax.get_figure() # get the figure of interest
    # attach the call back
    fig.canvas.mpl_connect('scroll_event',zoom_fun)

    #return the function
    return zoom_fun

So for a given figure:

t = np.linspace(0,250,5000)
y = sin(t)    

fig = figure()
ax = fig.add_subplot(111)
plt.plot(t,y)

max_xlim = ax.get_xlim() # get current x_limits to set max zoom out
max_ylim = ax.get_ylim() # get current y_limits to set max zoom out
f = zoom_factory(ax, max_xlim, max_ylim, base_scale=1.1)
show()

x = ginput(3)
adamluco
  • 39
  • 7
1

As I did not get any answer and I could not find much on the topic, here is how I solved this problem: I added a pre-procedure allowing the user to zoom in over a chosen area. When the area is suitable for point picking, the user simply has to press "Enter" and go on with ginput.

from __future__ import print_function
from pylab import arange, plot, sin, ginput, show
import matplotlib as plt  
from pylab import *
import numpy as np

def closest_point(vec,val):
    ind = np.where(vec==min(vec,key=lambda x:abs(x-val)))
    return ind[0][0]

t = np.linspace(0,250,5000)
y = sin(t)

fig = plt.figure()
plt.suptitle('chosing points over a possibly dense signal...',fontsize=14)
zoom_ok = False
while not zoom_ok:
    plt.plot(t,y)
    plt.title('1 - click on the two corners of the area to enlarge',fontsize=12)
    zoom = ginput(2,timeout=-1)
    xzoom = np.zeros([0])
    for i in range(2):
        xzoom = np.concatenate((xzoom,[int(closest_point(t,zoom[i][0]))]))  
    temps_zoom = t[xzoom[0]:xzoom[1]]
    dep_zoom = y[xzoom[0]:xzoom[1]]
    plt.clf()
    plt.plot(temps_zoom,dep_zoom,'b')
    plt.title('2 - if zoom ok -> press Enter, otherwise -> mouse click',fontsize=12)
    zoom_ok = plt.waitforbuttonpress()
plt.title('3 - you may now select the points ',fontsize=16)
x = ginput(2,timeout=-1)
plt.show()
Alain
  • 381
  • 3
  • 19
1

A workaround I'm using is to set the the mouse button arguments to None:

plt.ginput(n=0, timeout=0, mouse_add=None, mouse_pop=None, mouse_stop=None)

I then use the keyboard to add/pop/stop. (To add a point, move mouse to correct position and push Spacebar or j, etc. Use Delete to remove last point and Enter to stop.) This way, when I use the rectangle zoom with my mouse, I get no unwanted points.

Of course, some of the keyboard keys you might try might have other window/zoom-related side effects. (e.g. Backspace will both pop and reset the zoom), so you have to watch out.

jlarchibald
  • 41
  • 3