3

In a wxPython panel I want to use matplotlib's Lasso widget. In my implementation Lasso is used in three different functionalities. Nevertheless, in order to accomplish these functionalities I must combine key events with mouse button events.

By default, the initial Lasso function can be used by pressing the left mouse button. So, for my first functionality I press the left mouse button, select a region of interest and do something with the points included. For the second functionality, I would like to select another region of interest and do something else with these points.I am trying to do that by pressing shift+LMB. Finally, in my third functionality I would like to do something else with the selected points by pressing Ctrl+LMB.

Schematically, I would like to do the following:

 if left mouse button is pressed:
    use Lasso and with the included points do the 1st functionality

 if shift is press and left mouse button is pressed:

   use Lasso and with the included points do the 2nd functionality

 if ctrl is press and lmb is also pressed :
    call Lasso and with the included points do the 3rd functionality

Unfortunately, I can not achieve my goal and I get the following error: if self.shift_is_held == True: AttributeError: object has no attribute 'shift_is_held'. It seems that it can not recognize the button events, while in other cases the widgetlock command seems not to make the axes available.

Here are parts of my code: 

def scatter(self,data):
#create scatter plot
    fig = self._view_frame.figure
    fig.clf()

    Data = []
    self.lmans = []
    self.points_colors = []

    Data2 = []
    self.lmans_2 = []

    Data3 = []
    self.lmans_2 = []


    ax = fig.add_subplot('111')

    datum = []
    datum_2 = []
    datum_3 = []

    for x,y in zip(self.data[:,0],self.data[:,1]):
        datum.append(Datum(x,y))
        datum_2.append(Datum2(x,y))
        datum_3.append(Datum3(x,y))


    ax.scatter(self.data[:, 0], self.data[:, 1], s=150, marker='d')
    ax.set_xlim((min(self.data[:,0]), max(self.data[:,0])))
    ax.set_ylim((min(self.data[:,1]), max(self.data[:,1])))
    ax.set_aspect('auto')

    Data.append(datum)
    Data2.append(datum_2)
    Data3.append(datum_3)
    lman = self.LassoManager(ax, datum, Data)
    lman_2 = self.LassoManager2(ax, datum_2, Data2)
    lman_3 = self.LassoManager3(ax, datum_3, Data3)
    fig.canvas.draw()
    self.lmans.append(lman)
    self.lmans_2.append(lman_2)
    self.lmans_3.append(lman_3)
    fig.canvas.mpl_connect('axes_enter_event', self.enter_axes)


class Lasso(AxesWidget):


"""Selection curve of an arbitrary shape.

The selected path can be used in conjunction with
:func:`~matplotlib.path.Path.contains_point` to select data points
from an image.

Unlike :class:`LassoSelector`, this must be initialized with a starting
point `xy`, and the `Lasso` events are destroyed upon release.

Parameters:

*ax* : :class:`~matplotlib.axes.Axes`
    The parent axes for the widget.
*xy* : array
    Coordinates of the start of the lasso.
*callback* : function
    Whenever the lasso is released, the `callback` function is called and
    passed the vertices of the selected path.

"""

def __init__(self, ax, xy, callback=None, useblit=True):
    AxesWidget.__init__(self, ax)

    self.useblit = useblit and self.canvas.supports_blit
    if self.useblit:
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)

    x, y = xy
    self.verts = [(x, y)]
    self.line = Line2D([x], [y], linestyle='-', color='black', lw=2)
    self.ax.add_line(self.line)
    self.callback = callback
    self.connect_event('button_release_event', self.onrelease)
    self.connect_event('motion_notify_event', self.onmove)

def onrelease(self, event):
    if self.ignore(event):
        return
    if self.verts is not None:
        self.verts.append((event.xdata, event.ydata))
        if len(self.verts) > 2:
            self.callback(self.verts)
        self.ax.lines.remove(self.line)
    self.verts = None
    self.disconnect_events()

def onmove(self, event):
    if self.ignore(event):
        return
    if self.verts is None:
        return
    if event.inaxes != self.ax:
        return
    if event.button != 1:
        return
    self.verts.append((event.xdata, event.ydata))

    self.line.set_data(list(zip(*self.verts)))

    if self.useblit:
        self.canvas.restore_region(self.background)
        self.ax.draw_artist(self.line)
        self.canvas.blit(self.ax.bbox)
    else:
        self.canvas.draw_idle()

def enter_axes(self, event):
    self.idfig = event.inaxes.colNum
    self._view_frame.figure.canvas.mpl_connect('button_press_event', self.onpress_2)
    self._view_frame.figure.canvas.mpl_connect('key_press_event', self.onkey_press_2)
    self._view_frame.figure.canvas.mpl_connect('key_release_event', self.onkey_release_2)
    self._view_frame.figure.canvas.mpl_connect('button_press_event', self.onpress_3)
    self._view_frame.figure.canvas.mpl_connect('key_press_event', self.onkey_press_3)
    self._view_frame.figure.canvas.mpl_connect('key_release_event', self.onkey_release_3)

def LassoManager(self, ax, data, Data):
    self.axes = ax
    self.canvas = ax.figure.canvas
    self.data = data
    self.Data = Data
    self.Nxy = len(data)

    # self.facecolors = [d.color for d in data]
    self.xys = [(d.x, d.y) for d in data]
    fig = ax.figure
    #self.cid = self.canvas.mpl_connect('button_press_event', self.onpress)



def callback(self, verts):
    #facecolors = self.facecolors#collection.get_facecolors()
    #colorin = colorConverter.to_rgba('red')
    #colorout = colorConverter.to_rgba('blue')
    p = path.Path(verts)
    self.ind = p.contains_points([(d.x, d.y) for d in self.Data[self.where.colNum]])
    self._view_frame.figure.canvas.mpl_connect('button_press_event', self.onpress)

    #Functionality 1

    self.canvas.draw_idle()
    self.canvas.widgetlock.release(self.lasso)
    del self.lasso

def onpress(self,event):
     if self.canvas.widgetlock.locked(): return
        if event.inaxes is None: return
        self.lasso = Lasso(event.inaxes, (event.xdata, event.ydata), self.callback)
        self.where = event.inaxes
        # acquire a lock on the widget drawing
        self.canvas.widgetlock(self.lasso)

   def onkey_press_2(self,event):
    if event.key =='shift':
        self.merge_is_held = True


def onkey_press_3(self,event):
    if event.key == 'control':
        self.split_is_held = True

def onkey_release_2(self, event):
       if event.key == 'shift':
           self.merge_is_held = False


def onkey_release_3(self, event):
   if event.key == 'control':
        self.split_is_held = False

def LassoManagerMerge(self, ax, data2, Data2):
    self.axes = ax
    self.canvas = ax.figure.canvas
    self.data2 = data2
    self.Data2 = Data2
    self.Nxy = len(dataMerge)

    self.facecolors_2 = [d.color for d in data2]
    # print "facecolors",self.facecolors
    self.xys = [(d.x, d.y) for d in data2]
    # print "xys",self.xys
    fig = ax.figure
    self.collection_2 = RegularPolyCollection(
        fig.dpi, 6, sizes=(0,),
        facecolors=self.facecolors_2,
        offsets = self.xys,
        transOffset = ax.transData)

    ax.add_collection(self.collection_2)





def callback_2(self, verts):

    self.facecolors_2 = self.collection_2.get_facecolors()
    #colorin = colorConverter.to_rgba('red')
    #colorout = colorConverter.to_rgba('blue')
    p = path.Path(verts)
    self.ind = p.contains_points([(d.x, d.y) for d in self.Data2[self.where.colNum]])   
    #Functionality 2             

    self.canvas.draw_idle()
    self.canvas.widgetlock.release(self.lasso_2)

    del self.lasso_2

 def onpress_2(self, event):


            if self.canvas.widgetlock.locked():  return
            if event.inaxes is None: return
            if event.button == 1:
               if self.shift_is_held == True:
                    print "Shift pressed"
                    self.lasso_2 = Lasso(event.inaxes, (event.xdata, event.ydata), self.callback_2)
                    print "Shift pressed"
                    self.where = event.inaxes
                    self.canvas.widgetlock(self.lasso_2)

              def LassoManager3(self, ax, data3, Data3):
    self.axes = ax
    self.canvas = ax.figure.canvas
    self.data3 = data3
    self.Data3 = Data3
    self.Nxy = len(data3)

    self.facecolors_3= [d.color for d in data3]
    # print "facecolors",self.facecolors
    self.xys = [(d.x, d.y) for d in data3]

    # print "xys",self.xys
    fig = ax.figure
    self.collection_3 = RegularPolyCollection(
        fig.dpi, 6, sizes=(0,),
        facecolors=self.facecolors_3,
        offsets = self.xys,
        transOffset = ax.transData)

    ax.add_collection(self.collection_3)



def callback_3(self, verts):
    self.facecolors_3 = self.collection_3.get_facecolors()
    #colorin = colorConverter.to_rgba('red')
    #colorout = colorConverter.to_rgba('blue')
    p = path.Path(verts)
    self.ind = p.contains_points([(d.x, d.y) for d in self.Data3[self.where.colNum]])

    #Functionality 3
    self.canvas.draw_idle()
    self.canvas.widgetlock.release(self.lasso_3)

    del self.lasso_3

def onpress_3(self, event):

            if self.canvas.widgetlock.locked(): return
            if event.inaxes is None: return
            if event.button == 1:
                if self.split_is_held == True:
                    print " Split pressed"
                    self.lasso_3 = Lasso(event.inaxes, (event.xdata, event.ydata), self.callback_3)
                    print "Split pressed"
                    self.where = event.inaxes
                    # acquire a lock on the widget drawing
                    self.canvas.widgetlock(self.lasso_3)

Any suggestions?

Improve this question
2
  • Is this one helpful? stackoverflow.com/questions/31248228/… Commented Sep 1, 2015 at 1:19
  • Actually, it would be if it contained key events apart from mouse button events. Do you have any ideas how I could add key events in a wxPython panel in combination with the mouse events? Commented Sep 1, 2015 at 1:50

1 Answer 1

Reset to default
3

I'm not entirely sure what you're doing wrong because your code looks incomplete. I think your general idea was correct, but you seem to have been mixing up classes and trying to access the property shift_is_held from the wrong class or something.

I wrote this simple example using the lasso_example.py code from matplotlib examples. I did run into some complications trying to use the control key. When I try to drag with the mouse using the control key, the Lasso manager becomes unresponsive (including in the original code from matplotlib). I could not figure out why, so I used the shift and alt keys as modifiers in the present code.

You'll see that the logic of what action to perform depending on which key is held down at the moment when you release the lasso is performed in LassoManager.callback()

import logging
import matplotlib
from matplotlib.widgets import Lasso
from matplotlib.colors import colorConverter
from matplotlib.collections import RegularPolyCollection
from matplotlib import path

import matplotlib.pyplot as plt
from numpy.random import rand

logger = logging.getLogger()
logger.setLevel(logging.DEBUG)


class Datum(object):
    colorin = colorConverter.to_rgba('red')
    colorShift = colorConverter.to_rgba('cyan')
    colorCtrl = colorConverter.to_rgba('pink')
    colorout = colorConverter.to_rgba('blue')

    def __init__(self, x, y, include=False):
        self.x = x
        self.y = y
        if include:
            self.color = self.colorin
        else:
            self.color = self.colorout


class LassoManager(object):
    def __init__(self, ax, data):
        self.axes = ax
        self.canvas = ax.figure.canvas
        self.data = data

        self.Nxy = len(data)

        facecolors = [d.color for d in data]
        self.xys = [(d.x, d.y) for d in data]
        fig = ax.figure
        self.collection = RegularPolyCollection(
            fig.dpi, 6, sizes=(100,),
            facecolors=facecolors,
            offsets = self.xys,
            transOffset = ax.transData)

        ax.add_collection(self.collection)

        self.cid = self.canvas.mpl_connect('button_press_event', self.onpress)
        self.keyPress = self.canvas.mpl_connect('key_press_event', self.onKeyPress)
        self.keyRelease = self.canvas.mpl_connect('key_release_event', self.onKeyRelease)
        self.lasso = None
        self.shiftKey = False
        self.ctrlKey = False

    def callback(self, verts):
        logging.debug('in LassoManager.callback(). Shift: %s, Ctrl: %s' % (self.shiftKey, self.ctrlKey))
        facecolors = self.collection.get_facecolors()
        p = path.Path(verts)
        ind = p.contains_points(self.xys)
        for i in range(len(self.xys)):
            if ind[i]:
                if self.shiftKey:
                    facecolors[i] = Datum.colorShift
                elif self.ctrlKey:
                    facecolors[i] = Datum.colorCtrl
                else:
                    facecolors[i] = Datum.colorin
            else:
                facecolors[i] = Datum.colorout

        self.canvas.draw_idle()
        self.canvas.widgetlock.release(self.lasso)
        del self.lasso

    def onpress(self, event):
        if self.canvas.widgetlock.locked():
            return
        if event.inaxes is None:
            return
        self.lasso = Lasso(event.inaxes, (event.xdata, event.ydata), self.callback)
        # acquire a lock on the widget drawing
        self.canvas.widgetlock(self.lasso)

    def onKeyPress(self, event):
        logging.debug('in LassoManager.onKeyPress(). Event received: %s (key: %s)' % (event, event.key))
        if event.key == 'alt+alt':
            self.ctrlKey = True
        if event.key == 'shift':
            self.shiftKey = True

    def onKeyRelease(self, event):
        logging.debug('in LassoManager.onKeyRelease(). Event received: %s (key: %s)' % (event, event.key))
        if event.key == 'alt':
            self.ctrlKey = False
        if event.key == 'shift':
            self.shiftKey = False

if __name__ == '__main__':

    data = [Datum(*xy) for xy in rand(100, 2)]

    ax = plt.axes(xlim=(0,1), ylim=(0,1), autoscale_on=False)
    lman = LassoManager(ax, data)

    plt.show()
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thank you very much for your answer! Yours suggestion works great. I modified my code as you suggested by creating one callback function. I had also the same problem with the Ctrl button.
I also added on the code you posted a pick event, but it does not work at all. I can not get the index of the selected point. Isn't it possible to combine button press events with a pick event?? The canvas seems to get locked and after the call of the pick event I can not use the other functionalities as well. I added the modified code in this question.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.