laydi/system/plots.py

import logger
import pygtk
import gtk
import matplotlib
import scipy
import project
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
from matplotlib.axes import Subplot
from matplotlib.figure import Figure
from matplotlib.numerix import arange, sin, pi
from matplotlib.widgets import RectangleSelector


class MainView (gtk.Notebook):
    def __init__(self):
        gtk.Notebook.__init__(self)
        self.set_show_tabs(False)
        self.set_show_border(False)

        # Add a multiple pane view and a single pane view.
        self.small_view = SmallView()
        self.small_view.show()
        self.large_view = LargeView()
        self.large_view.show()

        self.append_page(self.small_view)
        self.append_page(self.large_view)
        self.set_current_page(0)
    
    def goto_small(self):
        if self.get_current_page() == 0:
            return None
        self.set_current_page(0)
        view = self.large_view.remove_child()
        self.small_view.return_current(view)

    def goto_large(self):
        if self.get_current_page() == 1:
            return None
        self.set_current_page(1)
        view = self.small_view.borrow_current()
        self.large_view.set_child(view)

    def show(self):
        gtk.Notebook.show(self)

    def insert_view(self, view):
        self.small_view.insert_view(view)

class SmallView (gtk.Table):
    def __init__(self):
        gtk.Table.__init__(self, 2, 2, True)

        self.child_views = [[EmptyView(), EmptyView()],
                            [EmptyView(), EmptyView()]]
        self.cols = 2
        self.rows = 2

        self.active_x = 0
        self.active_y = 0

        self.set_row_spacings(3)
        self.set_col_spacings(3)
        
        for x in range(self.cols):
            for y in range(self.rows):
                child = self.child_views[x][y]
                child.parent_signalling = child.connect('button_press_event', self.__view_button_event__)
                self.attach(child, x, x+1, y, y+1)

    def set_child(self, child, col, row):
        cur_widget = self.child_views[col][row]
        cur_widget.disconnect(cur_widget.parent_signalling)
        self.remove(cur_widget)
        self.attach(child, col, col+1, row, row+1)
        child.parent_signalling = child.connect('button_press_event', self.__view_button_event__)
        self.child_views[col][row] = child
        if cur_widget.active:
            child.mark_active(True)
            cur_widget.mark_active(False)
        child.show()

    def borrow_current(self):
        self.borrowed = self.child_views[self.active_x][self.active_y]
        self.remove_child(self.active_x, self.active_y)
        return self.borrowed

    def return_current(self, view):
        self.set_child(view, self.active_x, self.active_y)

    def remove_child(self, col, row):
        self.remove(self.child_views[col][row])
        self.attach(EmptyView(), col, col+1, row, row+1)
       
    def insert_view(self, child):
        if not self.find_child(child):
            self.set_child(child, self.active_x, self.active_y)

    def show(self):
        for x in self.child_views:
            for y in x:
                y.show()
        gtk.Table.show(self)

    def hide(self):
        for x in self.child_views:
            for y in x:
                y.hide()
        gtk.Table.hide(self)

    def set_active(self, x, y):
        old_focus = self.child_views[self.active_x][self.active_y]
        new_focus = self.child_views[x][y]
        old_focus.mark_active(False)
        new_focus.mark_active(True)
        self.active_x = x
        self.active_y = y

    def find_child(self, child):
        for i, row in enumerate(self.child_views):
            for j, v in enumerate(row):
                if v == child:
                    return (i, j)
        return None

    def __view_button_event__(self, view, *rest):
        loc = self.find_child(view)
        if loc:
            self.set_active(loc[0], loc[1])

    def get_view(self, x, y):
        return self.child_views[x][y]

class LargeView (gtk.Frame):
    def __init__(self):
        gtk.Frame.__init__(self)
        self.child_view = EmptyView()
        self.add(self.child_view)
    
    def set_child(self, child):
        self.remove(self.child_view)
        self.child_view.hide()
        self.add(child)
        self.child_view = child
        child.show()

    def hide(self):
        self.child_view.hide()
        gtk.Frame.hide(self)

    def show(self):
        self.child_view.show()
        gtk.Frame.show(self)

    def remove_child(self):
        child = self.child_view
        child.hide()
        self.remove(child)
        return child

class Plot (gtk.Frame):

    def __init__(self,project):
        gtk.Frame.__init__(self)
        self.project = project
        self.mark_active(False)
        self.connect('button_press_event', self.on_button_press)
        self.sel_obj = None
        self.active = False
        if project!=None: #its not an Emptyview
            project.attach(self,'selection_update')
        
    def on_button_press(self, *rest):
        logger.log('debug', 'button pressed in plot')
        self.mark_active(True)

    def mark_active(self, active):
        if active:
            self.set_shadow_type(gtk.SHADOW_IN)
        else:
            self.set_shadow_type(gtk.SHADOW_OUT)
        self.active = active

    def update(self,project,key):
        pass
    
class EmptyView (Plot):
    def __init__(self):
        Plot.__init__(self,None)
        
        label = gtk.Label('No view')
        ebox = gtk.EventBox()
        ebox.add(label)
        self.add(ebox)
        label.connect('button_press_event', self.on_button_press)

        self.label = label
        self.ebox = ebox
        self.show()

    def show(self):
        self.ebox.show()
        self.label.show()
        Plot.show(self)
        
    def hide(self):
        self.label.hide()
        self.ebox.hide()
        Plot.hide(self)
        

class SinePlot(Plot):
    def __init__(self,project):
        Plot.__init__(self,project)
        fig = Figure(figsize=(5,4), dpi=72)
        ax = fig.add_subplot(111)
        t = arange(0.0,3.0,0.01)
        s = sin(2*pi*t)
        ax.plot(t,s)
        self.canvas = FigureCanvas(fig)
        self.add(self.canvas)
        self.canvas.show()


class ScatterPlot(Plot):
    def __init__(self,project):
        Plot.__init__(self,project)
        fig = Figure(figsize=(5,4), dpi=72)
        self.ax = ax = fig.add_subplot(111)
        
        # testing testing
        self.x_dataset = project.datasets[0]
        x = self.x_dataset._data
        self.xaxis_data = xaxis_data =  x[:,0] + scipy.randn(scipy.shape(x)[0])
        self.yaxis_data = yaxis_data = x[:,1]
        self.current_dim = self.x_dataset._dim_names[0]
        ax.plot(xaxis_data,yaxis_data,'og')
        ###

        self.canvas = FigureCanvas(fig)
        self.add(self.canvas)
        rectprops = dict(facecolor='gray', edgecolor = 'black',
                                 alpha=0.2, fill=True) #cool
        sel = RectangleSelector(ax, self.rectangle_select_callback,
                      drawtype='box',useblit=True,rectprops=rectprops)
        
        self.canvas.show()

    def rectangle_select_callback(self,event1, event2):
        'event1 and event2 are the press and release events'
        x1, y1 = event1.xdata, event1.ydata
        x2, y2 = event2.xdata, event2.ydata
        logger.log('debug', "(%3.2f, %3.2f) --> (%3.2f, %3.2f)"%(x1,y1,x2,y2))
        logger.log('debug',"The button you used were:%s, %s "%(event1.button, event2.button))
        # get all points within x1, y1, x2, y2
        ydata = self.yaxis_data
        xdata = self.xaxis_data
        if x1>x2:
            logger.log('debug','Selection x_start bigger than x_end')
            if y1<y2:
                logger.log('debug','Selection y_start less than y_end')
                index =scipy.nonzero((xdata<x1) & (xdata>x2) & (ydata>y1) & (ydata<y2))
            else:
                logger.log('debug','Selection y_start larger than y_end')
                index =scipy.nonzero((xdata<x1) & (xdata>x2) & (ydata<y1) & (ydata>y2))
        else:
            logger.log('debug','Selection x_start less than x_end')
            if y1<y2:
                logger.log('debug','Selection y_start less than y_end')
                index =scipy.nonzero((xdata>x1) & (xdata<x2) & (ydata>y1) & (ydata<y2))
            else:
                logger.log('debug','Selection y_start bigger than y_end')
                index =scipy.nonzero((xdata>x1) & (xdata<x2) & (ydata<y1) & (ydata>y2))

        
        if len(index)==0:
            logger.log('debug','No points selected!')
        else:
            logger.log('debug','Selected:\n%s'%index)
            ids = self.x_dataset.extract_id_from_index('samples',index)
            #update selection object
            self.project.set_selection(self.current_dim,ids)
            logger.log('debug','Selected identifiers:\n%s'%ids)

    def update(self,project,key):
        curr_sel = project.get_selection() # get selection object
        ids = curr_sel[self.current_dim] # current identifiers
        index = self.x_dataset.extract_index_from_id(self.current_dim,ids) #conversion to index
        xdata_new = scipy.take(self.xaxis_data,index) #take data
        ydata_new = scipy.take(self.yaxis_data,index)
        self.ax.plot(self.xaxis_data,self.yaxis_data,'ob')
        self.ax.plot(xdata_new,ydata_new,'or')
        self.canvas.draw()