laydi/fluents/plots.py

import pygtk
import gobject
import gtk

import matplotlib
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg
from matplotlib.nxutils import points_inside_poly
from matplotlib.figure import Figure
from matplotlib.collections import LineCollection
from matplotlib.patches import Polygon,Rectangle,Circle
from matplotlib.lines import Line2D
from matplotlib.mlab import prctile
from matplotlib.colors import ColorConverter
import networkx
import scipy
from numpy import matlib

import fluents
import logger
import view

def plotlogger(func, name=None):
    def wrapped(parent, *args, **kw):
        parent.__args = args
        parent.__kw = kw
        return func(parent, *args, **kw)
    return wrapped


class Plot(view.View):
    def __init__(self, title):
        view.View.__init__(self, title)
        logger.log('debug', 'plot %s init' %title)
        self.selection_listener = None
        self.current_dim = None
        self._current_selection = None
        self._frozen = False
        self._init_mpl()
        
    def _init_mpl(self):    
        # init matplotlib related stuff 
        self._background = None
        self._colorbar = None
        self._mappable = None
        self._use_blit = False
        self.fig = Figure()
        self.canvas = FigureCanvasGTKAgg(self.fig)
        self.axes = self.fig.gca()
        self._toolbar = view.PlotToolbar(self)
        self._key_press = self.canvas.mpl_connect(
            'key_press_event', self.on_key_press)
        self.canvas.add_events(gtk.gdk.ENTER_NOTIFY_MASK)
        self.add(self.canvas)
        self.canvas.show()
        
    def set_frozen(self, frozen):
        """A frozen plot will not be updated when the current
        selection is changed."""
        self._frozen = frozen
        if not frozen and self._current_selection != None:
            self.set_current_selection(self._current_selection)
    
    def get_title(self):
        return self.title

    def get_toolbar(self):
        return self._toolbar
    
    def selection_changed(self, dim_name, selection):
        """ Selection observer handle.
        
        A selection change in a plot is only drawn if:
        1.) plot is sensitive to selections (not freezed)
        2.) plot is visible (has a view)
        3.) the selections dim_name is the plot's dimension.
        """
        
        self._current_selection = selection
        if self._frozen \
               or not self.get_property('visible') \
               or self.current_dim != dim_name:
            return

        self.set_current_selection(selection)

    def set_selection_listener(self, listener):
        """Allow project to listen to selections.

        The selection will propagate back to all plots through the
        selection_changed() method. The listener will be called as
        listener(dimension_name, ids).
        """
        self.selection_listener = listener

    def update_selection(self, ids, key=None):
        """Returns updated current selection from ids.
        If a key is pressed we use the appropriate mode.

        key map:
        shift : union
        control : intersection

        """
        print "Inside update selection, key: %s" %key
        if key == 'shift':
            ids = set(ids).union(self._current_selection[self.current_dim])
        elif key == 'control':
            ids = set(ids).intersection(self._current_selection[self.current_dim])
        return ids

    def set_current_selection(self, selection):
        """Called whenever the plot should change the selection.

        This method is a dummy method, so that specialized plots that have 
        no implemented selection can ignore selections alltogether.
        """
        pass

    def rectangle_select_callback(self, *args):
        """Overrriden in subclass."""
        if hasattr(self, 'canvas'):
            self.canvas.draw()

    def lasso_select_callback(self, *args):
        """Overrriden in subclass."""
        if hasattr(self, 'canvas'):
            self.canvas.draw()
    
    def get_index_from_selection(self, dataset, selection):
        """Returns the index vector of current selection in given dim."""
        if not selection: return []
        ids = selection.get(self.current_dim, []) # current identifiers
        if not ids : return []
        return dataset.get_indices(self.current_dim, ids)

    def on_key_press(self, event):
        if event.key == 'c':
            self._toggle_colorbar()

    def _toggle_colorbar(self):
        if self._colorbar == None:
            if self._mappable == None:
                logger.log('notice', 'No mappable in this plot')
                return
            if self._mappable._A != None: # we need colormapping
                # get axes original position
                self._ax_last_pos = self.axes.get_position()
                self._colorbar = self.fig.colorbar(self._mappable)
                self._colorbar.draw_all()
                self.canvas.draw()
        else:
            # remove colorbar
            # remove, axes, observers, colorbar instance, and restore viewlims 
            cb, ax = self._mappable.colorbar
            self.fig.delaxes(ax)
            self._mappable.observers = [obs for obs in self._mappable.observers if obs !=self._colorbar]
            self._colorbar = None
            self.axes.set_position(self._ax_last_pos)
            self.canvas.draw()
        

class LineViewPlot(Plot):
    """Line view plot with percentiles.

    A line view of vectors across a specified dimension of input dataset. 
    No selection interaction is defined.
    Only support for 2d-arrays.
    input:
           -- major_axis : dim_number for line dim (see scipy.ndarray for axis def.)
           -- minor_axis : needs definition only for higher order arrays

    fixme: slow
    """
    @plotlogger
    def __init__(self, dataset, major_axis=1, minor_axis=None, center=True,name="Line view"):
        Plot.__init__(self, name)
        self.dataset = dataset
        self._data = dataset.asarray()
        if len(self._data.shape)==2 and not minor_axis:
            minor_axis = major_axis - 1
        self.major_axis = major_axis
        self.minor_axis = minor_axis
        self.current_dim = self.dataset.get_dim_name(major_axis)
        self.data_is_centered = False
        self._mn_data = 0
        if center and len(self._data.shape)==2:
            if minor_axis==0:
                self._mn_data = self._data.mean(minor_axis)
            else:
                self._mn_data = self._data.mean(minor_axis)[:,newaxis]
            self._data = self._data - self._mn_data 
            self.data_is_centered = True
        #initial line collection
        self.line_coll = None
        self.make_lines()
        # draw background
        self.set_background()
        
        # Disable selection modes
        self._toolbar.freeze_button.set_sensitive(False)
        self._toolbar.set_mode_sensitive('select', False)
        self._toolbar.set_mode_sensitive('lassoselect', False)

    def make_lines(self):
        """Creates one line for each item along major axis."""
        if self.line_coll: # remove any previous selection lines, if any
            self.axes.collections.remove(self.line_coll)
        self.line_coll = None
        self.line_segs = []
        x_axis = scipy.arange(self._data.shape[self.minor_axis])
        for xi in range(self._data.shape[self.major_axis]):
            yi = self._data.take([xi], self.major_axis).ravel()
            self.line_segs.append([(xx,yy) for xx,yy in zip(x_axis, yi)])
        
    def set_background(self):
        """Add three patches representing [min max],[5,95] and [25,75] percentiles, and a line at the median.
        """
        if self._data.shape[self.minor_axis]<6:
            return
        # clean old patches if any
        if len(self.axes.patches)>0:
            self.axes.patches = []
        # clean old lines (median) if any
        if len(self.axes.lines)>0:
            self.axes.lines = []
        # settings
        patch_color = 'b' #blue
        patch_lw = 0 #no edges
        patch_alpha = .15 # transparancy
        median_color = 'b' #blue
        median_width = 1.5 #linewidth
        percentiles = [0, 5, 25, 50, 75, 100]

        # ordinate
        xax = scipy.arange(self._data.shape[self.minor_axis])

        #vertices
        verts_0 = [] #100,0
        verts_1 = [] # 90,10
        verts_2 = [] # 75,25
        med = [] 
        # add top vertices the low vertices (do i need an order?)#background
        for i in xax:
            prct = prctile(self._data.take([i], self.minor_axis), percentiles)
            verts_0.append((i, prct[0]))
            verts_1.append((i, prct[1]))
            verts_2.append((i, prct[2]))
            med.append(prct[3])
        for i in xax[::-1]:
            prct = prctile(self._data.take([i], self.minor_axis), percentiles)
            verts_0.append((i, prct[-1]))
            verts_1.append((i, prct[-2]))
            verts_2.append((i, prct[-3]))

        # make polygons from vertices
        bck0 = Polygon(verts_0, alpha=patch_alpha, lw=patch_lw,
                       facecolor=patch_color)
        bck1 = Polygon(verts_1, alpha=patch_alpha, lw=patch_lw,
                       facecolor=patch_color)
        bck2 = Polygon(verts_2, alpha=patch_alpha, lw=patch_lw,
                       facecolor=patch_color)

        # add polygons to axes
        self.axes.add_patch(bck0)
        self.axes.add_patch(bck1)
        self.axes.add_patch(bck2)
        # median line
        self.axes.plot(xax, med, median_color, linewidth=median_width)

        # set y-limits
        padding = 0.1
        self.axes.set_ylim([self._data.min() - padding, self._data.max() + padding])
                          
    def set_current_selection(self, selection):
        """Draws the current selection.
        """
        index = self.get_index_from_selection(self.dataset, selection)

        if self.line_coll:
            self.axes.collections.remove(self.line_coll)
        segs = [self.line_segs[i] for i in index]
        self.line_coll = LineCollection(segs, colors=(1,0,0,1))
        self.axes.add_collection(self.line_coll)
        
        #draw
        if self._use_blit:
            if self._background is None:
                self._background = self.canvas.copy_from_bbox(self.axes.bbox)
                self.canvas.restore_region(self._background)
            self.axes.draw_artist(self.lines)
            self.canvas.blit()
        else:
            self.canvas.draw()
            

class ScatterMarkerPlot(Plot):
    """The ScatterMarkerPlot is faster than regular scatterplot, but
       has no color and size options."""
    @plotlogger
    def __init__(self, dataset_1, dataset_2, id_dim, sel_dim,
                 id_1, id_2, s=6, name="Scatter plot"):
        Plot.__init__(self, name)
        self.current_dim = id_dim
        self.dataset_1 = dataset_1
        self.ms = s
        x_index = dataset_1[sel_dim][id_1]
        y_index = dataset_2[sel_dim][id_2]
        self.xaxis_data = dataset_1._array[:, x_index]
        self.yaxis_data = dataset_2._array[:, y_index]

        # init draw
        self._selection_line = None
        self.line = self.axes.plot(self.xaxis_data, 
                                   self.yaxis_data, 'o', 
                                   markeredgewidth=0, 
                                   markersize=s)
        self.axes.axhline(0, color='k', lw=1., zorder=1)
        self.axes.axvline(0, color='k', lw=1., zorder=1)

    def rectangle_select_callback(self, x1, y1, x2, y2, key):
        ydata = self.yaxis_data
        xdata = self.xaxis_data

        # find indices of selected area
        if x1>x2:
            x1, x2 = x2, x1
        if y1>y2:
            y1, y2 = y2, y1
        assert x1<=x2
        assert y1<=y2
        index = scipy.nonzero((xdata>x1) & (xdata<x2) & (ydata>y1) & (ydata<y2))[0]
        ids = self.dataset_1.get_identifiers(self.current_dim, index)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)

    def lasso_select_callback(self, verts, key=None):
        xys = scipy.c_[self.xaxis_data[:,scipy.newaxis], self.yaxis_data[:,scipy.newaxis]]
        index = scipy.nonzero(points_inside_poly(xys, verts))[0]
        ids = self.dataset_1.get_identifiers(self.current_dim, index)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)
    
    def set_current_selection(self, selection):
        #remove old selection
        if self._selection_line:
           self.axes.lines.remove(self._selection_line)
        index = self.get_index_from_selection(self.dataset_1, selection)
        if len(index)==0:
            # no selection
            self.canvas.draw()
            self._selection_line = None
            return
        
        xdata_new = self.xaxis_data.take(index) #take data
        ydata_new = self.yaxis_data.take(index)
        self._selection_line = Line2D(xdata_new, ydata_new
                                      ,marker='o', markersize=self.ms,
                                      linewidth=0, markerfacecolor='r',
                                      markeredgewidth=1.0)
        self.axes.add_line(self._selection_line)

        if self._use_blit:
            if self._background is None:
                self._background = self.canvas.copy_from_bbox(self.axes.bbox)
            self.canvas.restore_region(self._background)
            if self.selection_line:
                self.axes.draw_artist(self._selection_line)
            self.canvas.blit()
        else:
            self.canvas.draw()


class ScatterPlot(Plot):
    """The ScatterPlot is slower than scattermarker, but has size option."""
    @plotlogger
    def __init__(self, dataset_1, dataset_2, id_dim, sel_dim, id_1, id_2, c='b', s=30, sel_dim_2=None, name="Scatter plot", **kw):
        """Initializes a scatter plot.
        """

        Plot.__init__(self, name)
        self.dataset_1 = dataset_1
        self.s = s
        self.c = c
        self.kw = kw
        self.current_dim = id_dim
        self._map_ids = dataset_1.get_identifiers(id_dim, sorted=True)
        
        x_index = dataset_1[sel_dim][id_1]
        if sel_dim_2:
            y_index = dataset_2[sel_dim_2][id_2]
        else:
            y_index = dataset_2[sel_dim][id_2]
        self.xaxis_data = dataset_1._array[:, x_index]
        self.yaxis_data = dataset_2._array[:, y_index]

        # init draw
        self.init_draw()

        # signals to enable correct use of blit
        self.connect('zoom-changed', self.onzoom)
        self.connect('pan-changed', self.onpan)
        self.need_redraw = False
        self.canvas.mpl_connect('resize_event', self.onresize)

    def add_axes_spin_buttons(self, max=None, absi=0, ordi=1):    
        self._absi = absi
        self._ordi = ordi
        if max == None:
            max = 5
        sb_a = gtk.SpinButton(climb_rate=1)
        sb_a.set_range(1, max)
        sb_a.set_value(absi+1)
        sb_a.set_increments(1, 5)
        sb_a.connect('value_changed', self.set_absicca)
        sb_o = gtk.SpinButton(climb_rate=1)
        sb_o.set_range(1, max)
        sb_o.set_value(ordi+1)
        sb_o.set_increments(1, 5)
        sb_o.connect('value_changed', self.set_ordinate)
        hbox = gtk.HBox()
        gtk_label_a = gtk.Label(" A:")
        gtk_label_o = gtk.Label(" O:")
        toolitem = gtk.ToolItem()                          
        toolitem.set_expand(False)
        toolitem.set_border_width(2)
        toolitem.add(hbox)        
        hbox.pack_start(gtk_label_a)        
        hbox.pack_start(sb_a)
        hbox.pack_start(gtk_label_o)        
        hbox.pack_start(sb_o)
        self._toolbar.insert(toolitem, -1)
        toolitem.set_tooltip(self._toolbar.tooltips, "Set axis")
        self._toolbar.show_all() #do i need this?

    def set_absicca(self, sb):
        self._absi = sb.get_value_as_int() - 1
        xy = self.dataset_1._array[:,[self._absi, self._ordi]]
        self.xaxis_data = xy[:,0]
        self.yaxis_data = xy[:,1]
        self.sc._offsets = xy
        self.selection_collection._offsets = xy
        self.canvas.draw_idle()
        pad = abs(self.xaxis_data.min()-self.xaxis_data.max())*0.05
        new_lims = (self.xaxis_data.min() - pad, self.xaxis_data.max() + pad)
        self.axes.set_xlim(new_lims, emit=True)
        self.canvas.draw_idle()
        
    def set_ordinate(self, sb):
        self._ordi = sb.get_value_as_int() - 1
        xy = self.dataset_1._array[:,[self._absi, self._ordi]]
        self.xaxis_data = xy[:,0]
        self.yaxis_data = xy[:,1]
        self.sc._offsets = xy
        self.selection_collection._offsets = xy
        pad = abs(self.yaxis_data.min()-self.yaxis_data.max())*0.05
        new_lims = (self.yaxis_data.min() - pad, self.yaxis_data.max() + pad)
        self.axes.set_ylim(new_lims, emit=True)
        self.canvas.draw_idle()
    
    def onzoom(self, widget, mode):
        #logger.log('notice', 'Zoom in widget: %s' %widget)
        self.clean_redraw()
        
    def onpan(self, widget, mode):
        #logger.log('notice', 'Pan in widget: %s' %widget)
        self.clean_redraw()
        
    def onresize(self, widget):
        #logger.log('notice', 'resize event')
        self.clean_redraw()

    def clean_redraw(self):
        if self._use_blit == True:
            #logger.log('notice', 'blit -> clean redraw ')
            self.set_current_selection(None)
            self._background = self.canvas.copy_from_bbox(self.axes.bbox)
            self.set_current_selection(self._current_selection)
        else:
            self._background = None
        
    def init_draw(self):
        lw = scipy.zeros(self.xaxis_data.shape)
        self.sc = self.axes.scatter(self.xaxis_data, self.yaxis_data,
                                    s=self.s, c=self.c, linewidth=lw,
                                    zorder=3, **self.kw)
        self._mappable = self.sc
        self.selection_collection = self.axes.scatter(self.xaxis_data,
                                                      self.yaxis_data,
                                                      alpha=0,
                                                      c='w',s=self.s,
                                                      edgecolor='r',
                                                      linewidth=0,
                                                      zorder=4)
        self.axes.axhline(0, color='k', lw=1., zorder=1)
        self.axes.axvline(0, color='k', lw=1., zorder=1)
        # axhline and axvline mistakes the max/min using *all* data
        self._reset_limits(0)
        self._reset_limits(1)
        
        self._background = self.canvas.copy_from_bbox(self.axes.bbox)

    def _reset_limits(self, axis):
        if axis == 0:
            cax = self.xaxis_data
            set_lim = self.axes.set_xlim
        elif axis == 1:
            set_lim = self.axes.set_ylim
            cax = self.yaxis_data
        else:
            raise ValueError("Axis needs to be 0 or 1")
        pad = abs(cax.min()- cax.max())*0.05
        new_lims = (cax.min() - pad, cax.max() + pad)
        set_lim(new_lims, emit=True)
    
    def is_mappable_with(self, obj):
        """Returns True if dataset/selection is mappable with this plot.
        """
        if isinstance(obj, fluents.dataset.Dataset):
            if self.current_dim in obj.get_dim_name():
                return True
        
        elif isinstance(obj, fluents.dataset.Selection):
            if self.current_dim in obj.get_dim_name():
                return True

        else:
            return False
        
    def _update_color_from_dataset(self, data):
        """Updates the facecolors from a dataset.
        """
        array = data.asarray()
        #only support for 2d-arrays:
        try:
            m, n = array.shape
        except:
            raise ValueError, "No support for more than 2 dimensions."

        # is dataset a vector or matrix?
        if not n==1:
            # we have a category dataset
            if isinstance(data, fluents.dataset.CategoryDataset):
                vec = scipy.dot(array, scipy.diag(scipy.arange(n))).sum(1)
            else:
                vec = array.sum(1)
        else:
            vec = array.ravel()

        # 1.) Set all ids present in plot but not in dataset to gray
        # 2.) Set all ids which are inf/-inf/nan in dataset to gray

        # ids of scatterplot
        identifiers = self.dataset_1.get_identifiers(self.current_dim, sorted=True)
        # corresponding indices of input data
        indices = data.get_indices(self.current_dim, identifiers)
        # ids of scatterplot that is present in input data
        existing_ids = data.existing_identifiers(self.current_dim, identifiers)

        # use only values present in scatterplot
        v = vec[indices]
        vec_min = min(vec[vec > -scipy.inf])
        vec_max = max(vec[vec < scipy.inf])
        ptp = abs(vec_max - vec_min)
        # set all infs equal to max value + delta
        delta = 2.
        v[v==scipy.inf] = vec_max + delta
        v[v==-scipy.inf] = vec_max + delta
        v[v==scipy.nan] = vec_max + delta

        # get the indices of scatterplot ids present in input data
        indices = self.dataset_1.get_indices(self.current_dim, existing_ids)
        map_vec = vec_max*scipy.ones(len(identifiers))
        # setting all present values to v 
        map_vec[indices] = v
            
        # update facecolors
        self.sc.set_array(map_vec)
        self.sc.set_clim(vec_min, vec_max)
        self.sc.update_scalarmappable() #sets facecolors from array
        # adjust max values so they get one (1) bin in lut
        
        if hasattr(self.sc.cmap, "_lut"):
            #! fixme this is just a hack, not even tested
            lut_l = 1.*self.sc.cmap._lut.shape[0]
            map_vec_range = map_vec.ptp()
            delta_lut = map_vec_range/lut_l
            map_vec[vec_max + delta] = vec_max + delta_lut/2.
            self.sc.cmap._lut[-1,:] = [.5, .5, .5, 1]
        else:
            print "No lut present"
        self.canvas.draw()
                    
    def rectangle_select_callback(self, x1, y1, x2, y2, key):
        ydata = self.yaxis_data
        xdata = self.xaxis_data

        # find indices of selected area
        if x1>x2:
            x1, x2 = x2, x1
        if y1>y2:
            y1, y2 = y2, y1
        assert x1<=x2
        assert y1<=y2

        index = scipy.nonzero((xdata>x1) & (xdata<x2) & (ydata>y1) & (ydata<y2))[0]
        ids = self.dataset_1.get_identifiers(self.current_dim, index)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)

    def lasso_select_callback(self, verts, key=None):
        xys = scipy.c_[self.xaxis_data[:,scipy.newaxis], self.yaxis_data[:,scipy.newaxis]]
        index = scipy.nonzero(points_inside_poly(xys, verts))[0]
        ids = self.dataset_1.get_identifiers(self.current_dim, index)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)
        
    def set_current_selection(self, selection):
        linewidth = scipy.zeros(self.xaxis_data.shape, 'f')
        index = self.get_index_from_selection(self.dataset_1, selection)
        if len(index) > 0:
            linewidth[index] = 1.5
        self.selection_collection.set_linewidth(linewidth)
            
        if self._use_blit and len(index)>0 :
            if self._background is None:
                    self._background = self.canvas.copy_from_bbox(self.axes.bbox)
            self.canvas.restore_region(self._background)
            self.axes.draw_artist(self.selection_collection)
            self.canvas.blit()
        else:
            self.canvas.draw()
        
        
class ImagePlot(Plot):
    @plotlogger
    def __init__(self, dataset, **kw):
        Plot.__init__(self, kw.get('name', 'Image Plot'))
        self.dataset = dataset

        # Initial draw
        self.axes.grid(False)
        self.axes.imshow(dataset.asarray(), interpolation='nearest')
        self.axes.axis('tight')
        self._mappable = self.axes.images[0]

        # Disable selection modes
        self._toolbar.freeze_button.set_sensitive(False)
        self._toolbar.set_mode_sensitive('select', False)
        self._toolbar.set_mode_sensitive('lassoselect', False)

    
class HistogramPlot(Plot):
    """ Histogram plot.
    If dataset is 1-dim the current_dim is set and selections may
    be performed. For dataset> 1.dim the histogram is over all values
    and selections are not defined,"""
    @plotlogger
    def __init__(self, dataset, **kw):
        Plot.__init__(self, kw['name'])
        self.dataset = dataset
        self._data = dataset.asarray()

        # If dataset is 1-dim we may do selections
        if dataset.shape[0]==1:
            self.current_dim = dataset.get_dim_name(1)
        if dataset.shape[1]==1:
            self.current_dim = dataset.get_dim_name(0)

        # Set default paramteters
        if not kw.has_key('bins'):
            kw['bins'] = self._get_binsize()

        # Initial draw
        self.axes.grid(False)
        bins = min(self._data.size, kw['bins'])
        count, lims, self.patches = self.axes.hist(self._data, bins=bins)
        # Add identifiers to the individual patches
        if self.current_dim != None:
            for i, patch in enumerate(self.patches):
                if i==len(self.patches)-1:
                    end_lim = self._data.max() + 1
                else:
                    end_lim = lims[i+1]
                bool_ind = scipy.bitwise_and(self._data>=lims[i],
                                             self._data<=end_lim)
                patch.index = scipy.where(bool_ind)[0]

        if self.current_dim==None:
            # Disable selection modes
            logger.log('notice', 'Disabled selections in Histogram Plot')
            self._toolbar.freeze_button.set_sensitive(False)
            self._toolbar.set_mode_sensitive('select', False)
            self._toolbar.set_mode_sensitive('lassoselect', False)

    def rectangle_select_callback(self, x1, y1, x2, y2, key):
        if self.current_dim == None: return
        # make (x1, y1) the lower left corner
        if x1>x2:
            x1, x2 = x2, x1
        if y1>y2:
            y1, y2 = y2, y1

        self.active_patches = []
        for patch in self.patches:
            xmin = patch.xy[0]
            xmax = xmin + patch.get_width()
            ymin, ymax = -0.001, patch.get_height() 
            if xmax>x1 and xmin<x2 and (ymax> y2 or ymax>y1):
                self.active_patches.append(patch)
        if not self.active_patches: return

        ids = set()
        for patch in self.active_patches:
            ids.update(self.dataset.get_identifiers(self.current_dim,
                                                    patch.index))
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)

    def lasso_select_callback(self, verts, key):
        if self.current_dim == None: return
        self.active_patches = []
        for patch in self.patches:
            if scipy.any(points_inside_poly(verts, patch.get_verts())):
                self.active_patches.append(patch)
        if not self.active_patches: return
        ids = set()
        for patch in self.active_patches:
            ids.update(self.dataset.get_identifiers(self.current_dim,
                                                    patch.index))
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)

    def set_current_selection(self, selection):
        index = self.get_index_from_selection(self.dataset, selection)
        for patch in self.patches:
            patch.set_facecolor('b')
        for patch in self.patches:
            bin_selected = scipy.intersect1d(patch.index, index).size
            if bin_selected>0:
                bin_total = len(patch.index)
                # fixme: engineering color
                prop = -scipy.log(1.0*bin_selected/bin_total)
                b = min(prop, 1)
                r = max(.5, 1-b)
                g = 0
                patch.set_facecolor((r,g,b,1))
        self.canvas.draw()

    def _get_binsize(self, min_bins=2, max_bins=100):
        """ Automatic bin selection, as described by Shimazaki."""
        bin_vec = scipy.arange(min_bins, max_bins, 1)
        D = self._data.ptp()/bin_vec
        cost = scipy.empty((bin_vec.shape[0],), 'f')
        for i, bins in enumerate(bin_vec):
            count, lims = scipy.histogram(self._data, bins)
            cost[i] = (2*count.mean() - count.var())/(D[i]**2)
        best_bin_size = bin_vec[scipy.argmin(cost)]
        return best_bin_size

class BarPlot(Plot):
    """Bar plot.

    Ordinary bar plot for (column) vectors.
    For matrices there is one color for each row.
    """
    @plotlogger
    def __init__(self, dataset, **kw):
        Plot.__init__(self, kw.get('name', 'Bar Plot'))
        self.dataset = dataset
        
        # Initial draw
        self.axes.grid(False)
        n, m = dataset.shape
        if m>1:
            clrs = matplotlib.cm.ScalarMappable().to_rgba(range(n))
            for i, row in enumerate(dataset.asarray()):
                left = scipy.arange(i+1, m*n+1, n)
                height = row
                color = clrs[i]
                c = (color[0], color[1], color[2])
                self.axes.bar(left, height,color=c)
        else:
            height = dataset.asarray().ravel()
            left = scipy.arange(1, n+1, 1)
            self.axes.bar(left, height)

        # Disable selection modes
        self._toolbar.freeze_button.set_sensitive(False)
        self._toolbar.set_mode_sensitive('select', False)
        self._toolbar.set_mode_sensitive('lassoselect', False)
        

class NetworkPlot(Plot):
    @plotlogger
    def __init__(self, dataset, pos=None, nodecolor='b', nodesize=40,
                 prog='neato', with_labels=False, name='Network Plot'):

        Plot.__init__(self, name)
        self.dataset = dataset
        self.graph = dataset.asnetworkx()
        self._prog = prog
        self._pos = pos
        self._nodesize = nodesize
        self._nodecolor = nodecolor
        self._with_labels = with_labels
        
        self.current_dim = self.dataset.get_dim_name(0)

        if not self._pos:
            self._pos = networkx.graphviz_layout(self.graph, self._prog)
        self._xy = scipy.asarray([self._pos[node] for node in self.dataset.get_identifiers(self.current_dim, sorted=True)])
        self.xaxis_data = self._xy[:,0]
        self.yaxis_data = self._xy[:,1]

        # Initial draw
        self.default_props = {'nodesize' : 50,
                              'nodecolor' : 'blue',
                              'edge_color' : 'gray',
                              'edge_color_selected' : 'red'}
        self.node_collection = None
        self.edge_collection = None
        self.node_labels = None
        lw = scipy.zeros(self.xaxis_data.shape)
        self.node_collection = self.axes.scatter(self.xaxis_data, self.yaxis_data,
                                                 s=self._nodesize,
                                                 c=self._nodecolor,
                                                 linewidth=lw,
                                                 zorder=3)
        self._mappable = self.node_collection
        # selected nodes is a transparent graph that adjust node-edge visibility
        # according to the current selection needed to get get the selected
        # nodes 'on top' as zorder may not be defined individually
        self.selected_nodes = self.axes.scatter(self.xaxis_data,
                                                self.yaxis_data,
                                                s=self._nodesize,
                                                c=self._nodecolor,
                                                linewidth=lw,
                                                zorder=4,
                                                alpha=0)

        edge_color = self.default_props['edge_color']
        self.edge_collection = networkx.draw_networkx_edges(self.graph,
                                                            self._pos,
                                                            ax=self.axes,
                                                            edge_color=edge_color)
        # edge color rgba-arrays
        self._edge_color_rgba = matlib.repmat(ColorConverter().to_rgba(edge_color),
                                       self.graph.number_of_edges(),1)
        self._edge_color_selected = ColorConverter().to_rgba(self.default_props['edge_color_selected'])
        if self._with_labels:
            self.node_labels = networkx.draw_networkx_labels(self.graph,
                                                            self._pos,
                                                            ax=self.axes)
        
        # remove axes, frame and grid
        self.axes.set_xticks([])
        self.axes.set_yticks([])
        self.axes.grid(False)
        self.axes.set_frame_on(False)
        self.fig.subplots_adjust(left=0, right=1, bottom=0, top=1)

    def rectangle_select_callback(self, x1, y1, x2, y2, key):
        ydata = self.yaxis_data
        xdata = self.xaxis_data
        
        # find indices of selected area
        if x1>x2:
            x1, x2 = x2, x1
        if y1>y2:
            y1, y2 = y2, y1
        assert x1<=x2
        assert y1<=y2
        
        index = scipy.nonzero((xdata>x1) & (xdata<x2) & (ydata>y1) & (ydata<y2))[0]
        ids = self.dataset.get_identifiers(self.current_dim, index)
        print "ids in rsc: %s" %str(ids)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)

    def lasso_select_callback(self, verts, key=None):
        xys = scipy.c_[self.xaxis_data[:,scipy.newaxis], self.yaxis_data[:,scipy.newaxis]]
        index = scipy.nonzero(points_inside_poly(xys, verts))[0]
        ids = self.dataset.get_identifiers(self.current_dim, index)
        ids = self.update_selection(ids, key)
        self.selection_listener(self.current_dim, ids)
        
    def set_current_selection(self, selection):
        linewidth = scipy.zeros(self.xaxis_data.shape)
        edge_color_rgba = self._edge_color_rgba.copy()
        index = self.get_index_from_selection(self.dataset, selection)
        if len(index) > 0:
            linewidth[index] = 2
            idents = selection[self.current_dim]
            edge_index = [i for i,edge in enumerate(self.graph.edges()) if (edge[0] in idents and  edge[1] in idents)]
            if len(edge_index)>0:
                for i in edge_index:
                    edge_color_rgba[i,:] = self._edge_color_selected
                self._A = None
        
        self.edge_collection._colors = edge_color_rgba
        self.selected_nodes.set_linewidth(linewidth)
        self.canvas.draw()


class VennPlot(Plot):
    @plotlogger
    def __init__(self, name="Venn diagram"):
        Plot.__init__(self, name)

        # init draw
        self._init_bck()
        for c in self._venn_patches:
            self.axes.add_patch(c) 
        for mrk in self._markers:
            self.axes.add_patch(mrk)
        self.axes.set_xlim([-3, 3])
        self.axes.set_ylim([-2.5, 3.5])
        self._last_active = set()
        self.axes.set_xticks([])
        self.axes.set_yticks([])
        self.axes.axis('equal')
        self.axes.grid(False)
        self.axes.set_frame_on(False)
        self.fig.subplots_adjust(left=0, right=1, bottom=0, top=1)

    def _init_bck(self):
        res = 50
        a = .5
        r = 1.5
        mr = .2
        self.c1 = c1 =  Circle((-1,0), radius=r, alpha=a, facecolor='b')
        self.c2 = c2 = Circle((1,0), radius=r, alpha=a, facecolor='r')
        self.c3 = c3 = Circle((0, scipy.sqrt(3)), radius=r, alpha=a, facecolor='g')

        self.c1marker = Circle((-1.25, -.25), radius=mr, facecolor='y', alpha=0)
        self.c2marker = Circle((1.25, -.25), radius=mr, facecolor='y', alpha=0)
        self.c3marker = Circle((0, scipy.sqrt(3)+.25), radius=mr, facecolor='y', alpha=0)
        self.c1c2marker = Circle((0, -.15), radius=mr, facecolor='y', alpha=0)

        self.c1c3marker = Circle((-scipy.sqrt(2)/2, 1), radius=mr, facecolor='y', alpha=0)
        self.c2c3marker = Circle((scipy.sqrt(2)/2, 1), radius=mr, facecolor='y', alpha=0)
        self.c1c2c3marker = Circle((0, .6), radius=mr, facecolor='y', alpha=0)

        c1.elements = set(['a', 'b', 'c', 'f'])
        c2.elements = set(['a', 'c', 'd', 'e']) 
        c3.elements = set(['a', 'e', 'f', 'g'])
        self.active_elements = set()
        self.all_elements = c1.elements.union(c2.elements).union(c3.elements)

        c1.active = False
        c2.active = False
        c3.active = False

        c1.name = 'Blue'
        c2.name = 'Red'
        c3.name = 'Green'
        
        self._venn_patches = [c1, c2, c3]
        self._markers = [self.c1marker, self.c2marker, self.c3marker,
                         self.c1c2marker, self.c1c3marker,
                         self.c2c3marker, self.c1c2c3marker]

        self._tot_label = 'Tot: ' + str(len(self.all_elements))
        self._sel_label = 'Sel: ' + str(len(self.active_elements))
        self._legend = self.axes.legend((self._tot_label, self._sel_label),
                                       loc='upper right')
        
    def set_selection(self, selection, patch=None):
        if patch:
            patch.selection = selection
        else:
            selection_set = False
            for patch in self._venn_patches:
                if len(patch.elements)==0:
                    patch.elements = selection
                    selection_set = True
            if not selection_set:
                self.venn_patches[0].elements = selection
    
    def lasso_select_callback(self, verts, key=None):
        if verts==None:
            verts = (self._event.xdata, self._event.ydata)
        if key!='shift':
            for m in self._markers:
                m.set_alpha(0)
        
        self._patches_within_verts(verts, key)
        active = [i.active for i in self._venn_patches]
        if active==[True, False, False]:
            self.c1marker.set_alpha(1)
            self.active_elements = self.c1.elements.difference(self.c2.elements.union(self.c3.elements))
        elif active== [False, True, False]:
            self.c2marker.set_alpha(1)
            self.active_elements = self.c2.elements.difference(self.c1.elements.union(self.c3.elements))
        elif active== [False, False, True]:
            self.c3marker.set_alpha(1)
            self.active_elements = self.c3.elements.difference(self.c2.elements.union(self.c1.elements))
        elif active==[True, True, False]:
            self.c1c2marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c2.elements)
        elif active==[True, False, True]:
            self.c1c3marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c3.elements)
        elif active==[False, True, True]:
            self.c2c3marker.set_alpha(1)
            self.active_elements = self.c2.elements.intersection(self.c3.elements)
        elif active==[True, True, True]:
            self.c1c2c3marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c3.elements).intersection(self.c2.elements)

        if key=='shift':
            self.active_elements = self.active_elements.union(self._last_active)
        self._last_active = self.active_elements.copy()
        self._sel_label = 'Sel: ' + str(len(self.active_elements))
        self._legend.texts[1].set_text(self._sel_label)
        self.axes.figure.canvas.draw()

    def rectangle_select_callback(self, x1, y1, x2, y2, key):
        verts = [(x1, y1), (x2, y2)]
        if key!='shift':
            for m in self._markers:
                m.set_alpha(0)
        
        self._patches_within_verts(verts, key)
        active = [i.active for i in self._venn_patches]
        if active==[True, False, False]:
            self.c1marker.set_alpha(1)
            self.active_elements = self.c1.elements.difference(self.c2.elements.union(self.c3.elements))
        elif active== [False, True, False]:
            self.c2marker.set_alpha(1)
            self.active_elements = self.c2.elements.difference(self.c1.elements.union(self.c3.elements))
        elif active== [False, False, True]:
            self.c3marker.set_alpha(1)
            self.active_elements = self.c3.elements.difference(self.c2.elements.union(self.c1.elements))
        elif active==[True, True, False]:
            self.c1c2marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c2.elements)
        elif active==[True, False, True]:
            self.c1c3marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c3.elements)
        elif active==[False, True, True]:
            self.c2c3marker.set_alpha(1)
            self.active_elements = self.c2.elements.intersection(self.c3.elements)
        elif active==[True, True, True]:
            self.c1c2c3marker.set_alpha(1)
            self.active_elements = self.c1.elements.intersection(self.c3.elements).intersection(self.c2.elements)

        if key=='shift':
            self.active_elements = self.active_elements.union(self._last_active)
        self._last_active = self.active_elements.copy()
        self._sel_label = 'Sel: ' + str(len(self.active_elements))
        self._legend.texts[1].set_text(self._sel_label)
        self.axes.figure.canvas.draw()
        
    def _patches_within_verts(self, verts, key):
        xy = scipy.array(verts).mean(0)
        for venn_patch in self._venn_patches:
            venn_patch.active = False
            if self._distance(venn_patch.center,xy)<venn_patch.radius:
                venn_patch.active = True

    def _distance(self, (x1,y1),(x2,y2)):
        return scipy.sqrt( (x2-x1)**2 + (y2-y1)**2 )


class PlotThresholder:
    """Mixin class for plots that needs to filter nodes within a threshold
    range.
    """
    def __init__(self, text="x"):
        """Constructor.

        @param text: Name of the variable the threshold is on.
        """
        self._threshold_ds = None
        self._add_spin_buttons(text)
        self._sb_min.set_sensitive(False)
        self._sb_max.set_sensitive(False)

    def set_threshold_dataset(self, ds):
        """Sets the dataset to threshold on.

        @param ds: A dataset where one dimension corresponds to the select dimension
        in the plot, and any other dimensions have length 1
        """
        self._threshold_ds = ds
        self._sb_min.set_sensitive(True)
        self._sb_max.set_sensitive(True)

    def _add_spin_buttons(self, text):
        """Adds spin buttons to the toolbar for selecting minimum and maximum
        threshold values on information content."""
        sb_min = gtk.SpinButton(digits=2)
        sb_min.set_range(0, 100)
        sb_min.set_value(0)
        sb_min.set_increments(.1, 1.)
        sb_min.connect('value-changed', self._on_value_changed)
        self._sb_min = sb_min

        sb_max = gtk.SpinButton(digits=2)
        sb_max.set_range(0, 100)
        sb_max.set_value(1)
        sb_max.set_increments(.1, 1.)
        sb_max.connect('value-changed', self._on_value_changed)
        self._sb_max = sb_max

        label = gtk.Label(" < %s < " % text)
        hbox = gtk.HBox()
        hbox.pack_start(sb_min)
        hbox.pack_start(label)
        hbox.pack_start(sb_max)
        ti = gtk.ToolItem()
        ti.set_expand(False)
        ti.add(hbox)
        sb_min.show()
        sb_max.show()
        label.show()
        hbox.show()
        ti.show()
        self._toolbar.insert(ti, -1)
        ti.set_tooltip(self._toolbar.tooltips, "Set threshold")
        
    def set_threshold(self, min, max):
        """Sets min and max to the given values.
        Updates the plot accordingly to show only values that have a
        value within the boundaries. Other values are
        also excluded from being selected from the plot.
        @param ic_min Do not show nodes with IC below this value.
        @param ic_max Do not show nodes with IC above this value.
        """
        ds = self._threshold_ds
        if ds == None:
            return
        
        icnodes = ds.existing_identifiers('go-terms', self._map_ids)
        icindices = ds.get_indices('go-terms', icnodes)
        a = ds.asarray()[icindices].sum(1)
        
        good = set(scipy.array(icnodes)[(a>=min) & (a<=max)])

        sizes = scipy.zeros(len(self._map_ids))
        visible = set()
        for i, n in enumerate(self._map_ids):
            if n in good:
                sizes[i] = 50
                visible.add(n)
            else:
                sizes[i] = 0
        self.visible = visible
        
        self._mappable._sizes = sizes
        self.canvas.draw()

    def get_nodes_within_bounds(self):
        """Get a list of all nodes within the bounds of the selection in the
        seleted dataset.
        """
        pass

    def filter_nodes(self, nodes):
        """Filter a list of nodes and return only those that are within the
        threshold boundaries."""
        pass
        
    def _on_value_changed(self, sb):
        """Callback on spin button value changes."""
        min = self._sb_min.get_value()
        max = self._sb_max.get_value()
        self.set_threshold(min, max)

        
#class PlotContextMenu(gtk.Menu):
#    def __init__(self, plot):
#        gtk.Menu(self)
#        self._plot = plot
#        
#        # Populate main menu
##        self.color_item = gtk.MenuItem('Color')
#        self.append(self.color_item)
#        self.color_item.set_submenu(self.build_dataset_menu()):
#    
#    def build_dataset_menu(self):
#        return gtk.Menu()
        

# Create zoom-changed signal
gobject.signal_new('zoom-changed', Plot, gobject.SIGNAL_RUN_LAST, None,
                   (gobject.TYPE_PYOBJECT,))

# Create pan/zoom-changed signal
gobject.signal_new('pan-changed', Plot, gobject.SIGNAL_RUN_LAST, None,
                   (gobject.TYPE_PYOBJECT,))

# Create plot-resize-changed signal
gobject.signal_new('plot-resize-changed', Plot, gobject.SIGNAL_RUN_LAST, None,
                   (gobject.TYPE_PYOBJECT,))