-#!/usr/bin/env python
-
-'''
-HOOKE - A force spectroscopy review & analysis tool
-
-(C) 2008 Massimo Sandal
-
-Copyright (C) 2008 Massimo Sandal (University of Bologna, Italy).
-
-This program is released under the GNU General Public License version 2.
-'''
-
-from libhooke import HOOKE_VERSION
-from libhooke import WX_GOOD
-
-import os
-
-import wxversion
-wxversion.select(WX_GOOD)
-import wx
-import wxmpl
-from wx.lib.newevent import NewEvent
-
-import matplotlib.numerix as nx
-import scipy as sp
-
-from threading import *
-import Queue
-
-from hooke_cli import HookeCli
-from libhooke import *
-import libhookecurve as lhc
-
-#import file versions, just to know with what we're working...
-from hooke_cli import __version__ as hookecli_version
-
-global __version__
-global events_from_gui
-global config
-global CLI_PLUGINS
-global GUI_PLUGINS
-global LOADED_PLUGINS
-global PLOTMANIP_PLUGINS
-global FILE_DRIVERS
-
-__version__=HOOKE_VERSION[0]
-__release_name__=HOOKE_VERSION[1]
-
-events_from_gui=Queue.Queue() #GUI ---> CLI COMMUNICATION
-
-print 'Starting Hooke.'
-#CONFIGURATION FILE PARSING
-config_obj=HookeConfig()
-config=config_obj.load_config('hooke.conf')
-
-#IMPORTING PLUGINS
-
-CLI_PLUGINS=[]
-GUI_PLUGINS=[]
-PLOTMANIP_PLUGINS=[]
-LOADED_PLUGINS=[]
-
-plugin_commands_namespaces=[]
-plugin_gui_namespaces=[]
-for plugin_name in config['plugins']:
- try:
- plugin=__import__(plugin_name)
- try:
- eval('CLI_PLUGINS.append(plugin.'+plugin_name+'Commands)') #take Command plugin classes
- plugin_commands_namespaces.append(dir(eval('plugin.'+plugin_name+'Commands')))
- except:
- pass
- try:
- eval('GUI_PLUGINS.append(plugin.'+plugin_name+'Gui)') #take Gui plugin classes
- plugin_gui_namespaces.append(dir(eval('plugin.'+plugin_name+'Gui')))
- except:
- pass
- except ImportError:
- print 'Cannot find plugin ',plugin_name
- else:
- LOADED_PLUGINS.append(plugin_name)
- print 'Imported plugin ',plugin_name
-
-#eliminate names common to all namespaces
-for i in range(len(plugin_commands_namespaces)):
- plugin_commands_namespaces[i]=[item for item in plugin_commands_namespaces[i] if (item != '__doc__' and item != '__module__' and item != '_plug_init')]
-#check for conflicts in namespaces between plugins
-#FIXME: only in commands now, because I don't have Gui plugins to check
-#FIXME: how to check for plugin-defined variables (self.stuff) ??
-plugin_commands_names=[]
-whatplugin_defines=[]
-plugin_gui_names=[]
-for namespace,plugin_name in zip(plugin_commands_namespaces, config['plugins']):
- for item in namespace:
- if item in plugin_commands_names:
- i=plugin_commands_names.index(item) #we exploit the fact index gives the *first* occurrence of a name...
- print 'Error. Plugin ',plugin_name,' defines a function already defined by ',whatplugin_defines[i],'!'
- print 'This should not happen. Please disable one or both plugins and contact the plugin authors to solve the conflict.'
- print 'Hooke cannot continue.'
- exit()
- else:
- plugin_commands_names.append(item)
- whatplugin_defines.append(plugin_name)
-
-
-config['loaded_plugins']=LOADED_PLUGINS #FIXME: kludge -this should be global but not in config!
-#IMPORTING DRIVERS
-#FIXME: code duplication
-FILE_DRIVERS=[]
-LOADED_DRIVERS=[]
-for driver_name in config['drivers']:
- try:
- driver=__import__(driver_name)
- try:
- eval('FILE_DRIVERS.append(driver.'+driver_name+'Driver)')
- except:
- pass
- except ImportError:
- print 'Cannot find driver ',driver_name
- else:
- LOADED_DRIVERS.append(driver_name)
- print 'Imported driver ',driver_name
-config['loaded_drivers']=LOADED_DRIVERS
-
-#LIST OF CUSTOM WX EVENTS FOR CLI ---> GUI COMMUNICATION
-#FIXME: do they need to be here?
-list_of_events={}
-
-plot_graph, EVT_PLOT = NewEvent()
-list_of_events['plot_graph']=plot_graph
-
-plot_contact, EVT_PLOT_CONTACT = NewEvent()
-list_of_events['plot_contact']=plot_contact
-
-measure_points, EVT_MEASURE_POINTS = NewEvent()
-list_of_events['measure_points']=measure_points
-
-export_image, EVT_EXPORT_IMAGE = NewEvent()
-list_of_events['export_image']=export_image
-
-close_plot, EVT_CLOSE_PLOT = NewEvent()
-list_of_events['close_plot'] = close_plot
-
-show_plots, EVT_SHOW_PLOTS = NewEvent()
-list_of_events['show_plots'] = show_plots
-
-get_displayed_plot, EVT_GET_DISPLAYED_PLOT = NewEvent()
-list_of_events['get_displayed_plot'] = get_displayed_plot
-#------------
-
-class CliThread(Thread):
-
- def __init__(self,frame,list_of_events):
- Thread.__init__(self)
-
- #here we have to put temporary references to pass to the cli object.
- self.frame=frame
- self.list_of_events=list_of_events
-
- self.debug=0 #to be used in the future
-
- def run(self):
- print '\n\nThis is Hooke, version',__version__ , __release_name__
- print
- print '(c) Massimo Sandal & others, 2006-2008. Released under the GNU Lesser General Public License Version 3'
- print 'Hooke is Free software.'
- print '----'
- print ''
-
- def make_command_class(*bases):
- #FIXME: perhaps redundant
- return type(HookeCli)("HookeCliPlugged", bases + (HookeCli,), {})
- cli = make_command_class(*CLI_PLUGINS)(self.frame,self.list_of_events,events_from_gui,config,FILE_DRIVERS)
- cli.cmdloop()
-
-'''
-GUI CODE
-
-FIXME: put it in a separate module in the future?
-'''
-class MainMenuBar(wx.MenuBar):
- '''
- Creates the menu bar
- '''
- def __init__(self):
- wx.MenuBar.__init__(self)
- '''the menu description. the key of the menu is XX&Menu, where XX is a number telling
- the order of the menus on the menubar.
- &Menu is the Menu text
- the corresponding argument is ('&Item', 'itemname'), where &Item is the item text and itemname
- the inner reference to use in the self.menu_items dictionary.
-
- See create_menus() to see how it works
-
- Note: the mechanism on page 124 of "wxPython in Action" is less awkward, maybe, but I want
- binding to be performed later. Perhaps I'm wrong :)
- '''
-
- self.menu_desc={'00&File':[('&Open playlist','openplaymenu'),('&Exit','exitmenu')],
- '01&Edit':[('&Export text...','exporttextmenu'),('&Export image...','exportimagemenu')],
- '02&Help':[('&About Hooke','aboutmenu')]}
- self.create_menus()
-
- def create_menus(self):
- '''
- Smartish routine to create the menu from the self.menu_desc dictionary
- Hope it's a workable solution for the future.
- '''
- self.menus=[] #the menu objects to append to the menubar
- self.menu_items={} #the single menu items dictionary, to bind to events
-
- names=self.menu_desc.keys() #we gotta sort, because iterating keys goes in odd order
- names.sort()
-
- for name in names:
- self.menus.append(wx.Menu())
- for menu_item in self.menu_desc[name]:
- self.menu_items[menu_item[1]]=self.menus[-1].Append(-1, menu_item[0])
-
- for menu,name in zip(self.menus,names):
- self.Append(menu,name[2:])
-
-class MainPanel(wx.Panel):
- def __init__(self,parent,id):
-
- wx.Panel.__init__(self,parent,id)
- self.splitter = wx.SplitterWindow(self)
-
-ID_FRAME=100
-class MainWindow(wx.Frame):
- '''we make a frame inheriting wx.Frame and setting up things on the init'''
- def __init__(self,parent,id,title):
-
- #-----------------------------
- #WX WIDGETS INITIALIZATION
-
- wx.Frame.__init__(self,parent,ID_FRAME,title,size=(800,600),style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
-
- self.mainpanel=MainPanel(self,-1)
- self.cpanels=[]
-
- self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))
- self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))
-
- self.statusbar=wx.StatusBar(self,-1)
- self.SetStatusBar(self.statusbar)
-
- self.mainmenubar=MainMenuBar()
- self.SetMenuBar(self.mainmenubar)
-
- self.controls=[]
- self.figures=[]
- self.axes=[]
-
- #This is our matplotlib plot
- self.controls.append(wxmpl.PlotPanel(self.cpanels[0],-1))
- self.controls.append(wxmpl.PlotPanel(self.cpanels[1],-1))
- #These are our figure and axes, so to have easy references
- #Also, we initialize
- self.figures=[control.get_figure() for control in self.controls]
- self.axes=[figure.gca() for figure in self.figures]
-
- self.cpanels[1].Hide()
- self.mainpanel.splitter.Initialize(self.cpanels[0])
-
- self.sizer_dance() #place/size the widgets
-
- self.controls[0].SetSize(self.cpanels[0].GetSize())
- self.controls[1].SetSize(self.cpanels[1].GetSize())
-
- #-------------------------------------------
- #NON-WX WIDGETS INITIALIZATION
-
- #Flags.
- self.click_plot=0
-
- #FIXME: These could become a single flag with different (string?) values
- #self.on_measure_distance=False
- #self.on_measure_force=False
-
- self.plot_fit=False
-
- #Number of points to be clicked
- self.num_of_points = 2
-
- #Data.
- '''
- self.current_x_ext=[[],[]]
- self.current_y_ext=[[],[]]
- self.current_x_ret=[[],[]]
- self.current_y_ret=[[],[]]
-
-
- self.current_x_unit=[None,None]
- self.current_y_unit=[None,None]
- '''
-
- #Initialize xaxes, yaxes
- #FIXME: should come from config
- self.current_xaxes=0
- self.current_yaxes=0
-
- #Other
-
-
- self.index_buffer=[]
-
- self.clicked_points=[]
-
- self.measure_set=None
-
- self.events_from_gui = events_from_gui
-
- '''
- This dictionary keeps all the flags and the relative functon names that
- have to be called when a point is clicked.
- That is:
- - if point is clicked AND foo_flag=True
- - foo()
-
- Conversely, foo_flag is True if a corresponding event is launched by the CLI.
-
- self.ClickedPoints() takes care of handling this
- '''
-
- self.click_flags_functions={'measure_points':[False, 'MeasurePoints']}
-
- #Binding of custom events from CLI --> GUI functions!
- #FIXME: Should use the self.Bind() syntax
- EVT_PLOT(self, self.PlotCurve)
- EVT_PLOT_CONTACT(self, self.PlotContact)
- EVT_GET_DISPLAYED_PLOT(self, self.OnGetDisplayedPlot)
- EVT_MEASURE_POINTS(self, self.OnMeasurePoints)
- EVT_EXPORT_IMAGE(self,self.ExportImage)
- EVT_CLOSE_PLOT(self, self.OnClosePlot)
- EVT_SHOW_PLOTS(self, self.OnShowPlots)
-
- #This event and control decide what happens when I click on the plot 0.
- wxmpl.EVT_POINT(self, self.controls[0].GetId(), self.ClickPoint0)
- wxmpl.EVT_POINT(self, self.controls[1].GetId(), self.ClickPoint1)
-
- #RUN PLUGIN-SPECIFIC INITIALIZATION
- #make sure we execute _plug_init() for every command line plugin we import
- for plugin_name in config['plugins']:
- try:
- plugin=__import__(plugin_name)
- try:
- eval('plugin.'+plugin_name+'Gui._plug_init(self)')
- pass
- except AttributeError:
- pass
- except ImportError:
- pass
-
-
-
- #WX-SPECIFIC FUNCTIONS
- def sizer_dance(self):
- '''
- adjust size and placement of wxpython widgets.
- '''
- self.splittersizer = wx.BoxSizer(wx.VERTICAL)
- self.splittersizer.Add(self.mainpanel.splitter, 1, wx.EXPAND)
-
- self.plot1sizer = wx.BoxSizer()
- self.plot1sizer.Add(self.controls[0], 1, wx.EXPAND)
-
- self.plot2sizer = wx.BoxSizer()
- self.plot2sizer.Add(self.controls[1], 1, wx.EXPAND)
-
- self.panelsizer=wx.BoxSizer()
- self.panelsizer.Add(self.mainpanel, -1, wx.EXPAND)
-
- self.cpanels[0].SetSizer(self.plot1sizer)
- self.cpanels[1].SetSizer(self.plot2sizer)
-
- self.mainpanel.SetSizer(self.splittersizer)
- self.SetSizer(self.panelsizer)
-
- def binding_dance(self):
- self.Bind(wx.EVT_MENU, self.OnOpenPlayMenu, self.menubar.menu_items['openplaymenu'])
- self.Bind(wx.EVT_MENU, self.OnExitMenu, self.menubar.menu_items['exitmenu'])
- self.Bind(wx.EVT_MENU, self.OnExportText, self.menubar.menu_items['exporttextmenu'])
- self.Bind(wx.EVT_MENU, self.OnExportImage, self.menubar.menu_items['exportimagemenu'])
- self.Bind(wx.EVT_MENU, self.OnAboutMenu, self.menubar.menu_items['aboutmenu'])
-
- # DOUBLE PLOT MANAGEMENT
- #----------------------
- def show_both(self):
- '''
- Shows both plots.
- '''
- self.mainpanel.splitter.SplitHorizontally(self.cpanels[0],self.cpanels[1])
- self.mainpanel.splitter.SetSashGravity(0.5)
- self.mainpanel.splitter.SetSashPosition(300) #FIXME: we should get it and restore it
- self.mainpanel.splitter.UpdateSize()
-
- def close_plot(self,plot):
- '''
- Closes one plot - only if it's open
- '''
- if not self.cpanels[plot].IsShown():
- return
- if plot != 0:
- self.current_plot_dest = 0
- else:
- self.current_plot_dest = 1
- self.cpanels[plot].Hide()
- self.mainpanel.splitter.Unsplit(self.cpanels[plot])
- self.mainpanel.splitter.UpdateSize()
-
-
- def OnClosePlot(self,event):
- self.close_plot(event.to_close)
-
- def OnShowPlots(self,event):
- self.show_both()
-
-
- #FILE MENU FUNCTIONS
- #--------------------
- def OnOpenPlayMenu(self, event):
- pass
-
- def OnExitMenu(self,event):
- pass
-
- def OnExportText(self,event):
- pass
-
- def OnExportImage(self,event):
- pass
-
- def OnAboutMenu(self,event):
- pass
-
- #PLOT INTERACTION
- #----------------
- def PlotCurve(self,event):
- '''
- plots the current ext,ret curve.
- '''
- dest=0
-
- #FIXME: BAD kludge following. There should be a well made plot queue mechanism, with replacements etc.
- #---
- #If we have only one plot in the event, we already have one in self.plots and this is a secondary plot,
- #do not erase self.plots but append the new plot to it.
- if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) == 1:
- self.plots.append(event.plots[0])
- #if we already have two plots and a new secondary plot comes, we substitute the previous
- if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) > 1:
- self.plots[1] = event.plots[0]
- else:
- self.plots = event.plots
-
- #FIXME. Should be in PlotObject, somehow
- c=0
- for plot in self.plots:
- if self.plots[c].styles==[]:
- self.plots[c].styles=[None for item in plot.vectors]
- if self.plots[c].colors==[]:
- self.plots[c].colors=[None for item in plot.vectors]
-
- for plot in self.plots:
- '''
- MAIN LOOP FOR ALL PLOTS (now only 2 are allowed but...)
- '''
- if 'destination' in dir(plot):
- dest=plot.destination
-
- #if the requested panel is not shown, show it
- if not ( self.cpanels[dest].IsShown() ):
- self.show_both()
-
- self.axes[dest].hold(False)
- self.current_vectors=plot.vectors
- self.current_title=plot.title
- self.current_plot_dest=dest #let's try this way to take into account the destination plot...
-
- c=0
-
- if len(plot.colors)==0:
- plot.colors=[None] * len(plot.vectors)
- if len(plot.styles)==0:
- plot.styles=[None] * len(plot.vectors)
-
- for vectors_to_plot in self.current_vectors:
- if plot.styles[c]=='scatter':
- if plot.colors[c]==None:
- self.axes[dest].scatter(vectors_to_plot[0], vectors_to_plot[1])
- else:
- self.axes[dest].scatter(vectors_to_plot[0], vectors_to_plot[1],color=plot.colors[c])
- else:
- if plot.colors[c]==None:
- self.axes[dest].plot(vectors_to_plot[0], vectors_to_plot[1])
- else:
- self.axes[dest].plot(vectors_to_plot[0], vectors_to_plot[1], color=plot.colors[c])
- self.axes[dest].hold(True)
- c+=1
-
- '''
- for vectors_to_plot in self.current_vectors:
- if len(vectors_to_plot)==2: #3d plots are to come...
- if len(plot.styles) > 0 and plot.styles[c] == 'scatter':
- self.axes[dest].scatter(vectors_to_plot[0],vectors_to_plot[1])
- elif len(plot.styles) > 0 and plot.styles[c] == 'scatter_red':
- self.axes[dest].scatter(vectors_to_plot[0],vectors_to_plot[1],color='red')
- else:
- self.axes[dest].plot(vectors_to_plot[0],vectors_to_plot[1])
-
- self.axes[dest].hold(True)
- c+=1
- else:
- pass
- '''
- #FIXME: tackles only 2d plots
- self.axes[dest].set_xlabel(plot.units[0])
- self.axes[dest].set_ylabel(plot.units[1])
-
- #FIXME: set smaller fonts
- self.axes[dest].set_title(plot.title)
-
- if plot.xaxes:
- #swap X axis
- xlim=self.axes[dest].get_xlim()
- self.axes[dest].set_xlim((xlim[1],xlim[0]))
- if plot.yaxes:
- #swap Y axis
- ylim=self.axes[dest].get_ylim()
- self.axes[dest].set_ylim((ylim[1],ylim[0]))
-
- self.controls[dest].draw()
-
-
- def PlotContact(self,event):
- '''
- plots the contact point
- DEPRECATED!
- '''
- self.axes[0].hold(True)
- self.current_contact_index=event.contact_index
-
- #now we fake a clicked point
- self.clicked_points.append(ClickedPoint())
- self.clicked_points[-1].absolute_coords=self.current_x_ret[dest][self.current_contact_index], self.current_y_ret[dest][self.current_contact_index]
- self.clicked_points[-1].is_marker=True
-
- self._replot()
- self.clicked_points=[]
-
- def OnMeasurePoints(self,event):
- '''
- trigger flags to measure N points
- '''
- self.click_flags_functions['measure_points'][0]=True
- if 'num_of_points' in dir(event):
- self.num_of_points=event.num_of_points
- if 'set' in dir(event):
- self.measure_set=event.set
-
- def ClickPoint0(self,event):
- self.current_plot_dest=0
- self.ClickPoint(event)
- def ClickPoint1(self,event):
- self.current_plot_dest=1
- self.ClickPoint(event)
-
- def ClickPoint(self,event):
- '''
- this function decides what to do when we receive a left click on the axes.
- We trigger other functions:
- - the action chosen by the CLI sends an event
- - the event raises a flag : self.click_flags_functions['foo'][0]
- - the raised flag wants the function in self.click_flags_functions[1] to be called after a click
- '''
- for key, value in self.click_flags_functions.items():
- if value[0]:
- eval('self.'+value[1]+'(event)')
-
-
-
- def MeasurePoints(self,event,current_set=1):
- dest=self.current_plot_dest
- try:
- current_set=self.measure_set
- except AttributeError:
- pass
-
- #find the current plot matching the clicked destination
- plot=self._plot_of_dest()
- if len(plot.vectors)-1 < current_set: #what happens if current_set is 1 and we have only 1 vector?
- current_set=current_set-len(plot.vectors)
-
- xvector=plot.vectors[current_set][0]
- yvector=plot.vectors[current_set][1]
-
- self.clicked_points.append(ClickedPoint())
- self.clicked_points[-1].absolute_coords=event.xdata, event.ydata
- self.clicked_points[-1].find_graph_coords(xvector,yvector)
- self.clicked_points[-1].is_marker=True
- self.clicked_points[-1].is_line_edge=True
- self.clicked_points[-1].dest=dest
-
- self._replot()
-
- if len(self.clicked_points)==self.num_of_points:
- self.events_from_gui.put(self.clicked_points)
- #restore to default state:
- self.clicked_points=[]
- self.click_flags_functions['measure_points'][0]=False
-
-
- def OnGetDisplayedPlot(self,event):
- if 'dest' in dir(event):
- self.GetDisplayedPlot(event.dest)
- else:
- self.GetDisplayedPlot(self.current_plot_dest)
-
- def GetDisplayedPlot(self,dest):
- '''
- returns to the CLI the currently displayed plot for the given destination
- '''
- displayed_plot=self._plot_of_dest(dest)
- events_from_gui.put(displayed_plot)
-
- def ExportImage(self,event):
- '''
- exports an image as a file.
- Current supported file formats: png, eps
- (matplotlib docs say that jpeg should be supported too, but with .jpg it doesn't work for me!)
- '''
- #dest=self.current_plot_dest
- dest=event.dest
- filename=event.name
- self.figures[dest].savefig(filename)
-
- '''
- def _find_nearest_point(self, mypoint, dataset=1):
-
- #Given a clicked point on the plot, finds the nearest point in the dataset (in X) that
- #corresponds to the clicked point.
-
- dest=self.current_plot_dest
-
- xvector=plot.vectors[dataset][0]
- yvector=plot.vectors[dataset][1]
-
- #Ye Olde sorting algorithm...
- #FIXME: is there a better solution?
- index=0
- best_index=0
- best_diff=10^9 #hope we never go over this magic number :(
- for point in xvector:
- diff=abs(point-mypoint)
- if diff<best_diff:
- best_index=index
- best_diff=diff
- index+=1
-
- return best_index,xvector[best_index],yvector[best_index]
- '''
-
- def _plot_of_dest(self,dest=None):
- '''
- returns the plot that has the current destination
- '''
- if dest==None:
- dest=self.current_plot_dest
-
- plot=None
- for aplot in self.plots:
- if aplot.destination == dest:
- plot=aplot
- return plot
-
- def _replot(self):
- '''
- this routine is needed for a fresh clean-and-replot of interface
- otherwise, refreshing works very badly :(
-
- thanks to Ken McIvor, wxmpl author!
- '''
- dest=self.current_plot_dest
- #we get current zoom limits
- xlim=self.axes[dest].get_xlim()
- ylim=self.axes[dest].get_ylim()
- #clear axes
- self.axes[dest].cla()
-
- #Plot curve:
- #find the current plot matching the clicked destination
- plot=self._plot_of_dest()
- #plot all superimposed plots
- c=0
- if len(plot.colors)==0:
- plot.colors=[None] * len(plot.vectors)
- if len(plot.styles)==0:
- plot.styles=[None] * len(plot.vectors)
- for plotset in plot.vectors:
- if plot.styles[c]=='scatter':
- if plot.colors[c]==None:
- self.axes[dest].scatter(plotset[0], plotset[1])
- else:
- self.axes[dest].scatter(plotset[0], plotset[1],color=plot.colors[c])
- else:
- if plot.colors[c]==None:
- self.axes[dest].plot(plotset[0], plotset[1])
- else:
- self.axes[dest].plot(plotset[0], plotset[1], color=plot.colors[c])
- '''
- if len(plot.styles) > 0 and plot.styles[c]=='scatter':
- self.axes[dest].scatter(plotset[0], plotset[1],color=plot.colors[c])
- elif len(plot.styles) > 0 and plot.styles[c] == 'scatter_red':
- self.axes[dest].scatter(plotset[0],plotset[1],color='red')
- else:
- self.axes[dest].plot(plotset[0], plotset[1])
- '''
- c+=1
- #plot points we have clicked
- for item in self.clicked_points:
- if item.is_marker:
- if item.graph_coords==(None,None): #if we have no graph coords, we display absolute coords
- self.axes[dest].scatter([item.absolute_coords[0]],[item.absolute_coords[1]])
- else:
- self.axes[dest].scatter([item.graph_coords[0]],[item.graph_coords[1]])
-
- if self.plot_fit:
- print 'DEBUGGING WARNING: use of self.plot_fit is deprecated!'
- self.axes[dest].plot(self.plot_fit[0],self.plot_fit[1])
-
- self.axes[dest].hold(True)
- #set old axes again
- self.axes[dest].set_xlim(xlim)
- self.axes[dest].set_ylim(ylim)
- #set title and names again...
- self.axes[dest].set_title(self.current_title)
- self.axes[dest].set_xlabel(plot.units[0])
- self.axes[dest].set_ylabel(plot.units[1])
- #and redraw!
- self.controls[dest].draw()
-
-
-class MySplashScreen(wx.SplashScreen):
- """
- Create a splash screen widget.
- That's just a fancy addition... every serious application has a splash screen!
- """
- def __init__(self, frame):
- # This is a recipe to a the screen.
- # Modify the following variables as necessary.
- #aBitmap = wx.Image(name = "wxPyWiki.jpg").ConvertToBitmap()
- aBitmap=wx.Image(name='hooke.jpg').ConvertToBitmap()
- splashStyle = wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT
- splashDuration = 2000 # milliseconds
- splashCallback = None
- # Call the constructor with the above arguments in exactly the
- # following order.
- wx.SplashScreen.__init__(self, aBitmap, splashStyle,
- splashDuration, None, -1)
- wx.EVT_CLOSE(self, self.OnExit)
- self.frame=frame
- wx.Yield()
-
- def OnExit(self, evt):
- self.Hide()
-
- self.frame.Show()
- # The program will freeze without this line.
- evt.Skip() # Make sure the default handler runs too...
-
-
-#------------------------------------------------------------------------------
-
-def main():
-
- #save the directory where Hooke is located
- config['hookedir']=os.getcwd()
-
- #now change to the working directory.
- try:
- os.chdir(config['workdir'])
- except OSError:
- print "Warning: Invalid work directory."
-
- app=wx.PySimpleApp()
-
- def make_gui_class(*bases):
- return type(MainWindow)("MainWindowPlugged", bases + (MainWindow,), {})
-
- main_frame = make_gui_class(*GUI_PLUGINS)(None, -1, ('Hooke '+__version__))
-
- #FIXME. The frame.Show() is called by the splashscreen here! Ugly as hell.
-
- mysplash=MySplashScreen(main_frame)
- mysplash.Show()
-
- my_cmdline=CliThread(main_frame, list_of_events)
- my_cmdline.start()
-
-
- app.MainLoop()
-
-main()
+#!/usr/bin/env python\r
+\r
+'''\r
+HOOKE - A force spectroscopy review & analysis tool\r
+\r
+(C) 2008 Massimo Sandal\r
+\r
+Copyright (C) 2008 Massimo Sandal (University of Bologna, Italy).\r
+\r
+This program is released under the GNU General Public License version 2.\r
+'''\r
+\r
+from libhooke import HOOKE_VERSION\r
+from libhooke import WX_GOOD\r
+\r
+import os\r
+\r
+import wxversion\r
+wxversion.select(WX_GOOD)\r
+import wx\r
+import wxmpl\r
+from wx.lib.newevent import NewEvent\r
+\r
+import matplotlib.numerix as nx\r
+import scipy as sp\r
+\r
+from threading import *\r
+import Queue\r
+\r
+from hooke_cli import HookeCli\r
+from libhooke import *\r
+import libhookecurve as lhc\r
+\r
+#import file versions, just to know with what we're working...\r
+from hooke_cli import __version__ as hookecli_version\r
+\r
+global __version__\r
+global events_from_gui\r
+global config\r
+global CLI_PLUGINS\r
+global GUI_PLUGINS\r
+global LOADED_PLUGINS\r
+global PLOTMANIP_PLUGINS\r
+global FILE_DRIVERS\r
+\r
+__version__=HOOKE_VERSION[0]\r
+__release_name__=HOOKE_VERSION[1]\r
+\r
+events_from_gui=Queue.Queue() #GUI ---> CLI COMMUNICATION\r
+\r
+print 'Starting Hooke.'\r
+#CONFIGURATION FILE PARSING\r
+config_obj=HookeConfig()\r
+config=config_obj.load_config('hooke.conf')\r
+\r
+#IMPORTING PLUGINS\r
+\r
+CLI_PLUGINS=[]\r
+GUI_PLUGINS=[]\r
+PLOTMANIP_PLUGINS=[]\r
+LOADED_PLUGINS=[]\r
+\r
+plugin_commands_namespaces=[]\r
+plugin_gui_namespaces=[]\r
+for plugin_name in config['plugins']:\r
+ try:\r
+ plugin=__import__(plugin_name)\r
+ try:\r
+ eval('CLI_PLUGINS.append(plugin.'+plugin_name+'Commands)') #take Command plugin classes\r
+ plugin_commands_namespaces.append(dir(eval('plugin.'+plugin_name+'Commands')))\r
+ except:\r
+ pass\r
+ try:\r
+ eval('GUI_PLUGINS.append(plugin.'+plugin_name+'Gui)') #take Gui plugin classes\r
+ plugin_gui_namespaces.append(dir(eval('plugin.'+plugin_name+'Gui')))\r
+ except:\r
+ pass\r
+ except ImportError:\r
+ print 'Cannot find plugin ',plugin_name\r
+ else:\r
+ LOADED_PLUGINS.append(plugin_name)\r
+ print 'Imported plugin ',plugin_name\r
+\r
+#eliminate names common to all namespaces\r
+for i in range(len(plugin_commands_namespaces)):\r
+ plugin_commands_namespaces[i]=[item for item in plugin_commands_namespaces[i] if (item != '__doc__' and item != '__module__' and item != '_plug_init')]\r
+#check for conflicts in namespaces between plugins\r
+#FIXME: only in commands now, because I don't have Gui plugins to check\r
+#FIXME: how to check for plugin-defined variables (self.stuff) ??\r
+plugin_commands_names=[]\r
+whatplugin_defines=[]\r
+plugin_gui_names=[]\r
+for namespace,plugin_name in zip(plugin_commands_namespaces, config['plugins']):\r
+ for item in namespace:\r
+ if item in plugin_commands_names:\r
+ i=plugin_commands_names.index(item) #we exploit the fact index gives the *first* occurrence of a name...\r
+ print 'Error. Plugin ',plugin_name,' defines a function already defined by ',whatplugin_defines[i],'!'\r
+ print 'This should not happen. Please disable one or both plugins and contact the plugin authors to solve the conflict.'\r
+ print 'Hooke cannot continue.'\r
+ exit()\r
+ else:\r
+ plugin_commands_names.append(item)\r
+ whatplugin_defines.append(plugin_name)\r
+\r
+\r
+config['loaded_plugins']=LOADED_PLUGINS #FIXME: kludge -this should be global but not in config!\r
+#IMPORTING DRIVERS\r
+#FIXME: code duplication\r
+FILE_DRIVERS=[]\r
+LOADED_DRIVERS=[]\r
+for driver_name in config['drivers']:\r
+ try:\r
+ driver=__import__(driver_name)\r
+ try:\r
+ eval('FILE_DRIVERS.append(driver.'+driver_name+'Driver)')\r
+ except:\r
+ pass\r
+ except ImportError:\r
+ print 'Cannot find driver ',driver_name\r
+ else:\r
+ LOADED_DRIVERS.append(driver_name)\r
+ print 'Imported driver ',driver_name\r
+config['loaded_drivers']=LOADED_DRIVERS\r
+\r
+#LIST OF CUSTOM WX EVENTS FOR CLI ---> GUI COMMUNICATION\r
+#FIXME: do they need to be here?\r
+list_of_events={}\r
+\r
+plot_graph, EVT_PLOT = NewEvent()\r
+list_of_events['plot_graph']=plot_graph\r
+\r
+plot_contact, EVT_PLOT_CONTACT = NewEvent()\r
+list_of_events['plot_contact']=plot_contact\r
+\r
+measure_points, EVT_MEASURE_POINTS = NewEvent()\r
+list_of_events['measure_points']=measure_points\r
+\r
+export_image, EVT_EXPORT_IMAGE = NewEvent()\r
+list_of_events['export_image']=export_image\r
+\r
+close_plot, EVT_CLOSE_PLOT = NewEvent()\r
+list_of_events['close_plot'] = close_plot\r
+\r
+show_plots, EVT_SHOW_PLOTS = NewEvent()\r
+list_of_events['show_plots'] = show_plots\r
+\r
+get_displayed_plot, EVT_GET_DISPLAYED_PLOT = NewEvent()\r
+list_of_events['get_displayed_plot'] = get_displayed_plot\r
+#------------\r
+\r
+class CliThread(Thread):\r
+\r
+ def __init__(self,frame,list_of_events):\r
+ Thread.__init__(self)\r
+\r
+ #here we have to put temporary references to pass to the cli object.\r
+ self.frame=frame\r
+ self.list_of_events=list_of_events\r
+\r
+ self.debug=0 #to be used in the future\r
+\r
+ def run(self):\r
+ print '\n\nThis is Hooke, version',__version__ , __release_name__\r
+ print\r
+ print '(c) Massimo Sandal & others, 2006-2008. Released under the GNU Lesser General Public License Version 3'\r
+ print 'Hooke is Free software.'\r
+ print '----'\r
+ print ''\r
+\r
+ def make_command_class(*bases):\r
+ #FIXME: perhaps redundant\r
+ return type(HookeCli)("HookeCliPlugged", bases + (HookeCli,), {})\r
+ cli = make_command_class(*CLI_PLUGINS)(self.frame,self.list_of_events,events_from_gui,config,FILE_DRIVERS)\r
+ cli.cmdloop()\r
+\r
+'''\r
+GUI CODE\r
+\r
+FIXME: put it in a separate module in the future?\r
+'''\r
+class MainMenuBar(wx.MenuBar):\r
+ '''\r
+ Creates the menu bar\r
+ '''\r
+ def __init__(self):\r
+ wx.MenuBar.__init__(self)\r
+ '''the menu description. the key of the menu is XX&Menu, where XX is a number telling\r
+ the order of the menus on the menubar.\r
+ &Menu is the Menu text\r
+ the corresponding argument is ('&Item', 'itemname'), where &Item is the item text and itemname\r
+ the inner reference to use in the self.menu_items dictionary.\r
+\r
+ See create_menus() to see how it works\r
+\r
+ Note: the mechanism on page 124 of "wxPython in Action" is less awkward, maybe, but I want\r
+ binding to be performed later. Perhaps I'm wrong :)\r
+ ''' \r
+\r
+ self.menu_desc={'00&File':[('&Open playlist','openplaymenu'),('&Exit','exitmenu')], \r
+ '01&Edit':[('&Export text...','exporttextmenu'),('&Export image...','exportimagemenu')],\r
+ '02&Help':[('&About Hooke','aboutmenu')]}\r
+ self.create_menus()\r
+\r
+ def create_menus(self):\r
+ '''\r
+ Smartish routine to create the menu from the self.menu_desc dictionary\r
+ Hope it's a workable solution for the future.\r
+ '''\r
+ self.menus=[] #the menu objects to append to the menubar\r
+ self.menu_items={} #the single menu items dictionary, to bind to events\r
+\r
+ names=self.menu_desc.keys() #we gotta sort, because iterating keys goes in odd order\r
+ names.sort()\r
+\r
+ for name in names:\r
+ self.menus.append(wx.Menu())\r
+ for menu_item in self.menu_desc[name]:\r
+ self.menu_items[menu_item[1]]=self.menus[-1].Append(-1, menu_item[0])\r
+\r
+ for menu,name in zip(self.menus,names):\r
+ self.Append(menu,name[2:])\r
+\r
+class MainPanel(wx.Panel):\r
+ def __init__(self,parent,id): \r
+\r
+ wx.Panel.__init__(self,parent,id)\r
+ self.splitter = wx.SplitterWindow(self)\r
+\r
+ID_FRAME=100 \r
+class MainWindow(wx.Frame):\r
+ '''we make a frame inheriting wx.Frame and setting up things on the init'''\r
+ def __init__(self,parent,id,title):\r
+\r
+ #-----------------------------\r
+ #WX WIDGETS INITIALIZATION\r
+\r
+ wx.Frame.__init__(self,parent,ID_FRAME,title,size=(800,600),style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)\r
+\r
+ self.mainpanel=MainPanel(self,-1)\r
+ self.cpanels=[]\r
+\r
+ self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))\r
+ self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))\r
+\r
+ self.statusbar=wx.StatusBar(self,-1)\r
+ self.SetStatusBar(self.statusbar)\r
+\r
+ self.mainmenubar=MainMenuBar()\r
+ self.SetMenuBar(self.mainmenubar)\r
+\r
+ self.controls=[]\r
+ self.figures=[]\r
+ self.axes=[]\r
+\r
+ #This is our matplotlib plot\r
+ self.controls.append(wxmpl.PlotPanel(self.cpanels[0],-1))\r
+ self.controls.append(wxmpl.PlotPanel(self.cpanels[1],-1))\r
+ #These are our figure and axes, so to have easy references\r
+ #Also, we initialize\r
+ self.figures=[control.get_figure() for control in self.controls]\r
+ self.axes=[figure.gca() for figure in self.figures]\r
+\r
+ self.cpanels[1].Hide()\r
+ self.mainpanel.splitter.Initialize(self.cpanels[0])\r
+\r
+ self.sizer_dance() #place/size the widgets\r
+\r
+ self.controls[0].SetSize(self.cpanels[0].GetSize())\r
+ self.controls[1].SetSize(self.cpanels[1].GetSize())\r
+\r
+ #resize the frame to properly draw on Windows\r
+ frameSize=self.GetSize()\r
+ frameSize.DecBy(1, 1)\r
+ self.SetSize(frameSize)\r
+ '''\r
+ #if you need the exact same size as before DecBy, uncomment this block\r
+ frameSize.IncBy(1, 1)\r
+ self.SetSize(frameSize)\r
+ '''\r
+\r
+ #-------------------------------------------\r
+ #NON-WX WIDGETS INITIALIZATION\r
+\r
+ #Flags.\r
+ self.click_plot=0\r
+\r
+ #FIXME: These could become a single flag with different (string?) values\r
+ #self.on_measure_distance=False\r
+ #self.on_measure_force=False\r
+\r
+ self.plot_fit=False\r
+\r
+ #Number of points to be clicked\r
+ self.num_of_points = 2\r
+\r
+ #Data.\r
+ '''\r
+ self.current_x_ext=[[],[]]\r
+ self.current_y_ext=[[],[]]\r
+ self.current_x_ret=[[],[]]\r
+ self.current_y_ret=[[],[]]\r
+\r
+\r
+ self.current_x_unit=[None,None]\r
+ self.current_y_unit=[None,None]\r
+ '''\r
+\r
+ #Initialize xaxes, yaxes\r
+ #FIXME: should come from config\r
+ self.current_xaxes=0\r
+ self.current_yaxes=0\r
+\r
+ #Other\r
+\r
+\r
+ self.index_buffer=[]\r
+\r
+ self.clicked_points=[]\r
+\r
+ self.measure_set=None\r
+\r
+ self.events_from_gui = events_from_gui\r
+\r
+ '''\r
+ This dictionary keeps all the flags and the relative functon names that\r
+ have to be called when a point is clicked.\r
+ That is:\r
+ - if point is clicked AND foo_flag=True\r
+ - foo()\r
+\r
+ Conversely, foo_flag is True if a corresponding event is launched by the CLI.\r
+\r
+ self.ClickedPoints() takes care of handling this\r
+ '''\r
+\r
+ self.click_flags_functions={'measure_points':[False, 'MeasurePoints']}\r
+\r
+ #Binding of custom events from CLI --> GUI functions! \r
+ #FIXME: Should use the self.Bind() syntax\r
+ EVT_PLOT(self, self.PlotCurve)\r
+ EVT_PLOT_CONTACT(self, self.PlotContact)\r
+ EVT_GET_DISPLAYED_PLOT(self, self.OnGetDisplayedPlot)\r
+ EVT_MEASURE_POINTS(self, self.OnMeasurePoints)\r
+ EVT_EXPORT_IMAGE(self,self.ExportImage)\r
+ EVT_CLOSE_PLOT(self, self.OnClosePlot)\r
+ EVT_SHOW_PLOTS(self, self.OnShowPlots)\r
+\r
+ #This event and control decide what happens when I click on the plot 0.\r
+ wxmpl.EVT_POINT(self, self.controls[0].GetId(), self.ClickPoint0)\r
+ wxmpl.EVT_POINT(self, self.controls[1].GetId(), self.ClickPoint1)\r
+\r
+ #RUN PLUGIN-SPECIFIC INITIALIZATION\r
+ #make sure we execute _plug_init() for every command line plugin we import\r
+ for plugin_name in config['plugins']:\r
+ try:\r
+ plugin=__import__(plugin_name)\r
+ try:\r
+ eval('plugin.'+plugin_name+'Gui._plug_init(self)')\r
+ pass\r
+ except AttributeError:\r
+ pass\r
+ except ImportError:\r
+ pass\r
+\r
+\r
+\r
+ #WX-SPECIFIC FUNCTIONS\r
+ def sizer_dance(self):\r
+ '''\r
+ adjust size and placement of wxpython widgets.\r
+ '''\r
+ self.splittersizer = wx.BoxSizer(wx.VERTICAL)\r
+ self.splittersizer.Add(self.mainpanel.splitter, 1, wx.EXPAND)\r
+\r
+ self.plot1sizer = wx.BoxSizer()\r
+ self.plot1sizer.Add(self.controls[0], 1, wx.EXPAND)\r
+\r
+ self.plot2sizer = wx.BoxSizer()\r
+ self.plot2sizer.Add(self.controls[1], 1, wx.EXPAND)\r
+\r
+ self.panelsizer=wx.BoxSizer()\r
+ self.panelsizer.Add(self.mainpanel, -1, wx.EXPAND)\r
+\r
+ self.cpanels[0].SetSizer(self.plot1sizer)\r
+ self.cpanels[1].SetSizer(self.plot2sizer)\r
+\r
+ self.mainpanel.SetSizer(self.splittersizer)\r
+ self.SetSizer(self.panelsizer)\r
+\r
+ def binding_dance(self):\r
+ self.Bind(wx.EVT_MENU, self.OnOpenPlayMenu, self.menubar.menu_items['openplaymenu'])\r
+ self.Bind(wx.EVT_MENU, self.OnExitMenu, self.menubar.menu_items['exitmenu'])\r
+ self.Bind(wx.EVT_MENU, self.OnExportText, self.menubar.menu_items['exporttextmenu'])\r
+ self.Bind(wx.EVT_MENU, self.OnExportImage, self.menubar.menu_items['exportimagemenu'])\r
+ self.Bind(wx.EVT_MENU, self.OnAboutMenu, self.menubar.menu_items['aboutmenu'])\r
+\r
+ # DOUBLE PLOT MANAGEMENT\r
+ #----------------------\r
+ def show_both(self):\r
+ '''\r
+ Shows both plots.\r
+ '''\r
+ self.mainpanel.splitter.SplitHorizontally(self.cpanels[0],self.cpanels[1])\r
+ self.mainpanel.splitter.SetSashGravity(0.5)\r
+ self.mainpanel.splitter.SetSashPosition(300) #FIXME: we should get it and restore it\r
+ self.mainpanel.splitter.UpdateSize()\r
+\r
+ def close_plot(self,plot):\r
+ '''\r
+ Closes one plot - only if it's open\r
+ '''\r
+ if not self.cpanels[plot].IsShown():\r
+ return\r
+ if plot != 0:\r
+ self.current_plot_dest = 0\r
+ else:\r
+ self.current_plot_dest = 1\r
+ self.cpanels[plot].Hide()\r
+ self.mainpanel.splitter.Unsplit(self.cpanels[plot])\r
+ self.mainpanel.splitter.UpdateSize()\r
+\r
+\r
+ def OnClosePlot(self,event):\r
+ self.close_plot(event.to_close) \r
+\r
+ def OnShowPlots(self,event):\r
+ self.show_both()\r
+\r
+\r
+ #FILE MENU FUNCTIONS\r
+ #--------------------\r
+ def OnOpenPlayMenu(self, event):\r
+ pass \r
+\r
+ def OnExitMenu(self,event):\r
+ pass\r
+\r
+ def OnExportText(self,event):\r
+ pass\r
+\r
+ def OnExportImage(self,event):\r
+ pass\r
+\r
+ def OnAboutMenu(self,event):\r
+ pass\r
+\r
+ #PLOT INTERACTION \r
+ #---------------- \r
+ def PlotCurve(self,event):\r
+ '''\r
+ plots the current ext,ret curve.\r
+ '''\r
+ dest=0\r
+\r
+ #FIXME: BAD kludge following. There should be a well made plot queue mechanism, with replacements etc.\r
+ #---\r
+ #If we have only one plot in the event, we already have one in self.plots and this is a secondary plot,\r
+ #do not erase self.plots but append the new plot to it.\r
+ if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) == 1:\r
+ self.plots.append(event.plots[0])\r
+ #if we already have two plots and a new secondary plot comes, we substitute the previous\r
+ if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) > 1:\r
+ self.plots[1] = event.plots[0]\r
+ else:\r
+ self.plots = event.plots\r
+\r
+ #FIXME. Should be in PlotObject, somehow\r
+ c=0\r
+ for plot in self.plots:\r
+ if self.plots[c].styles==[]:\r
+ self.plots[c].styles=[None for item in plot.vectors] \r
+ if self.plots[c].colors==[]:\r
+ self.plots[c].colors=[None for item in plot.vectors] \r
+\r
+ for plot in self.plots:\r
+ '''\r
+ MAIN LOOP FOR ALL PLOTS (now only 2 are allowed but...)\r
+ '''\r
+ if 'destination' in dir(plot):\r
+ dest=plot.destination\r
+\r
+ #if the requested panel is not shown, show it\r
+ if not ( self.cpanels[dest].IsShown() ):\r
+ self.show_both()\r
+\r
+ self.axes[dest].hold(False)\r
+ self.current_vectors=plot.vectors\r
+ self.current_title=plot.title\r
+ self.current_plot_dest=dest #let's try this way to take into account the destination plot...\r
+\r
+ c=0\r
+\r
+ if len(plot.colors)==0:\r
+ plot.colors=[None] * len(plot.vectors)\r
+ if len(plot.styles)==0:\r
+ plot.styles=[None] * len(plot.vectors) \r
+\r
+ for vectors_to_plot in self.current_vectors: \r
+ if plot.styles[c]=='scatter':\r
+ if plot.colors[c]==None:\r
+ self.axes[dest].scatter(vectors_to_plot[0], vectors_to_plot[1])\r
+ else:\r
+ self.axes[dest].scatter(vectors_to_plot[0], vectors_to_plot[1],color=plot.colors[c])\r
+ else:\r
+ if plot.colors[c]==None:\r
+ self.axes[dest].plot(vectors_to_plot[0], vectors_to_plot[1])\r
+ else:\r
+ self.axes[dest].plot(vectors_to_plot[0], vectors_to_plot[1], color=plot.colors[c])\r
+ self.axes[dest].hold(True)\r
+ c+=1\r
+\r
+ '''\r
+ for vectors_to_plot in self.current_vectors:\r
+ if len(vectors_to_plot)==2: #3d plots are to come...\r
+ if len(plot.styles) > 0 and plot.styles[c] == 'scatter':\r
+ self.axes[dest].scatter(vectors_to_plot[0],vectors_to_plot[1])\r
+ elif len(plot.styles) > 0 and plot.styles[c] == 'scatter_red':\r
+ self.axes[dest].scatter(vectors_to_plot[0],vectors_to_plot[1],color='red')\r
+ else:\r
+ self.axes[dest].plot(vectors_to_plot[0],vectors_to_plot[1])\r
+\r
+ self.axes[dest].hold(True)\r
+ c+=1\r
+ else:\r
+ pass\r
+ ''' \r
+ #FIXME: tackles only 2d plots\r
+ self.axes[dest].set_xlabel(plot.units[0])\r
+ self.axes[dest].set_ylabel(plot.units[1])\r
+\r
+ #FIXME: set smaller fonts\r
+ self.axes[dest].set_title(plot.title)\r
+\r
+ if plot.xaxes: \r
+ #swap X axis\r
+ xlim=self.axes[dest].get_xlim()\r
+ self.axes[dest].set_xlim((xlim[1],xlim[0])) \r
+ if plot.yaxes:\r
+ #swap Y axis\r
+ ylim=self.axes[dest].get_ylim() \r
+ self.axes[dest].set_ylim((ylim[1],ylim[0])) \r
+\r
+ self.controls[dest].draw()\r
+\r
+\r
+ def PlotContact(self,event):\r
+ '''\r
+ plots the contact point\r
+ DEPRECATED!\r
+ '''\r
+ self.axes[0].hold(True)\r
+ self.current_contact_index=event.contact_index\r
+\r
+ #now we fake a clicked point \r
+ self.clicked_points.append(ClickedPoint())\r
+ self.clicked_points[-1].absolute_coords=self.current_x_ret[dest][self.current_contact_index], self.current_y_ret[dest][self.current_contact_index]\r
+ self.clicked_points[-1].is_marker=True \r
+\r
+ self._replot()\r
+ self.clicked_points=[]\r
+\r
+ def OnMeasurePoints(self,event):\r
+ '''\r
+ trigger flags to measure N points\r
+ '''\r
+ self.click_flags_functions['measure_points'][0]=True\r
+ if 'num_of_points' in dir(event):\r
+ self.num_of_points=event.num_of_points\r
+ if 'set' in dir(event): \r
+ self.measure_set=event.set \r
+\r
+ def ClickPoint0(self,event):\r
+ self.current_plot_dest=0\r
+ self.ClickPoint(event)\r
+ def ClickPoint1(self,event):\r
+ self.current_plot_dest=1\r
+ self.ClickPoint(event)\r
+\r
+ def ClickPoint(self,event):\r
+ '''\r
+ this function decides what to do when we receive a left click on the axes.\r
+ We trigger other functions:\r
+ - the action chosen by the CLI sends an event\r
+ - the event raises a flag : self.click_flags_functions['foo'][0]\r
+ - the raised flag wants the function in self.click_flags_functions[1] to be called after a click\r
+ '''\r
+ for key, value in self.click_flags_functions.items():\r
+ if value[0]:\r
+ eval('self.'+value[1]+'(event)')\r
+\r
+\r
+\r
+ def MeasurePoints(self,event,current_set=1):\r
+ dest=self.current_plot_dest\r
+ try:\r
+ current_set=self.measure_set\r
+ except AttributeError:\r
+ pass\r
+\r
+ #find the current plot matching the clicked destination\r
+ plot=self._plot_of_dest()\r
+ if len(plot.vectors)-1 < current_set: #what happens if current_set is 1 and we have only 1 vector?\r
+ current_set=current_set-len(plot.vectors)\r
+\r
+ xvector=plot.vectors[current_set][0]\r
+ yvector=plot.vectors[current_set][1]\r
+\r
+ self.clicked_points.append(ClickedPoint()) \r
+ self.clicked_points[-1].absolute_coords=event.xdata, event.ydata\r
+ self.clicked_points[-1].find_graph_coords(xvector,yvector)\r
+ self.clicked_points[-1].is_marker=True \r
+ self.clicked_points[-1].is_line_edge=True\r
+ self.clicked_points[-1].dest=dest \r
+\r
+ self._replot()\r
+\r
+ if len(self.clicked_points)==self.num_of_points:\r
+ self.events_from_gui.put(self.clicked_points)\r
+ #restore to default state:\r
+ self.clicked_points=[]\r
+ self.click_flags_functions['measure_points'][0]=False \r
+\r
+\r
+ def OnGetDisplayedPlot(self,event):\r
+ if 'dest' in dir(event):\r
+ self.GetDisplayedPlot(event.dest)\r
+ else:\r
+ self.GetDisplayedPlot(self.current_plot_dest)\r
+\r
+ def GetDisplayedPlot(self,dest):\r
+ '''\r
+ returns to the CLI the currently displayed plot for the given destination\r
+ '''\r
+ displayed_plot=self._plot_of_dest(dest)\r
+ events_from_gui.put(displayed_plot)\r
+\r
+ def ExportImage(self,event):\r
+ '''\r
+ exports an image as a file.\r
+ Current supported file formats: png, eps\r
+ (matplotlib docs say that jpeg should be supported too, but with .jpg it doesn't work for me!)\r
+ '''\r
+ #dest=self.current_plot_dest\r
+ dest=event.dest\r
+ filename=event.name\r
+ self.figures[dest].savefig(filename)\r
+\r
+ '''\r
+ def _find_nearest_point(self, mypoint, dataset=1):\r
+\r
+ #Given a clicked point on the plot, finds the nearest point in the dataset (in X) that\r
+ #corresponds to the clicked point.\r
+\r
+ dest=self.current_plot_dest\r
+\r
+ xvector=plot.vectors[dataset][0]\r
+ yvector=plot.vectors[dataset][1]\r
+\r
+ #Ye Olde sorting algorithm...\r
+ #FIXME: is there a better solution?\r
+ index=0\r
+ best_index=0\r
+ best_diff=10^9 #hope we never go over this magic number :(\r
+ for point in xvector:\r
+ diff=abs(point-mypoint)\r
+ if diff<best_diff:\r
+ best_index=index\r
+ best_diff=diff\r
+ index+=1\r
+\r
+ return best_index,xvector[best_index],yvector[best_index]\r
+ ''' \r
+\r
+ def _plot_of_dest(self,dest=None):\r
+ '''\r
+ returns the plot that has the current destination\r
+ '''\r
+ if dest==None:\r
+ dest=self.current_plot_dest\r
+\r
+ plot=None\r
+ for aplot in self.plots:\r
+ if aplot.destination == dest:\r
+ plot=aplot\r
+ return plot\r
+\r
+ def _replot(self):\r
+ '''\r
+ this routine is needed for a fresh clean-and-replot of interface\r
+ otherwise, refreshing works very badly :(\r
+\r
+ thanks to Ken McIvor, wxmpl author!\r
+ '''\r
+ dest=self.current_plot_dest\r
+ #we get current zoom limits\r
+ xlim=self.axes[dest].get_xlim()\r
+ ylim=self.axes[dest].get_ylim() \r
+ #clear axes\r
+ self.axes[dest].cla()\r
+\r
+ #Plot curve: \r
+ #find the current plot matching the clicked destination\r
+ plot=self._plot_of_dest()\r
+ #plot all superimposed plots \r
+ c=0 \r
+ if len(plot.colors)==0:\r
+ plot.colors=[None] * len(plot.vectors)\r
+ if len(plot.styles)==0:\r
+ plot.styles=[None] * len(plot.vectors) \r
+ for plotset in plot.vectors: \r
+ if plot.styles[c]=='scatter':\r
+ if plot.colors[c]==None:\r
+ self.axes[dest].scatter(plotset[0], plotset[1])\r
+ else:\r
+ self.axes[dest].scatter(plotset[0], plotset[1],color=plot.colors[c])\r
+ else:\r
+ if plot.colors[c]==None:\r
+ self.axes[dest].plot(plotset[0], plotset[1])\r
+ else:\r
+ self.axes[dest].plot(plotset[0], plotset[1], color=plot.colors[c])\r
+ ''' \r
+ if len(plot.styles) > 0 and plot.styles[c]=='scatter':\r
+ self.axes[dest].scatter(plotset[0], plotset[1],color=plot.colors[c])\r
+ elif len(plot.styles) > 0 and plot.styles[c] == 'scatter_red':\r
+ self.axes[dest].scatter(plotset[0],plotset[1],color='red')\r
+ else:\r
+ self.axes[dest].plot(plotset[0], plotset[1])\r
+ '''\r
+ c+=1\r
+ #plot points we have clicked\r
+ for item in self.clicked_points:\r
+ if item.is_marker:\r
+ if item.graph_coords==(None,None): #if we have no graph coords, we display absolute coords\r
+ self.axes[dest].scatter([item.absolute_coords[0]],[item.absolute_coords[1]])\r
+ else:\r
+ self.axes[dest].scatter([item.graph_coords[0]],[item.graph_coords[1]]) \r
+\r
+ if self.plot_fit:\r
+ print 'DEBUGGING WARNING: use of self.plot_fit is deprecated!'\r
+ self.axes[dest].plot(self.plot_fit[0],self.plot_fit[1])\r
+\r
+ self.axes[dest].hold(True) \r
+ #set old axes again\r
+ self.axes[dest].set_xlim(xlim)\r
+ self.axes[dest].set_ylim(ylim)\r
+ #set title and names again...\r
+ self.axes[dest].set_title(self.current_title) \r
+ self.axes[dest].set_xlabel(plot.units[0])\r
+ self.axes[dest].set_ylabel(plot.units[1])\r
+ #and redraw!\r
+ self.controls[dest].draw()\r
+\r
+\r
+class MySplashScreen(wx.SplashScreen):\r
+ """\r
+ Create a splash screen widget.\r
+ That's just a fancy addition... every serious application has a splash screen!\r
+ """\r
+ def __init__(self, frame):\r
+ # This is a recipe to a the screen.\r
+ # Modify the following variables as necessary.\r
+ #aBitmap = wx.Image(name = "wxPyWiki.jpg").ConvertToBitmap()\r
+ aBitmap=wx.Image(name='hooke.jpg').ConvertToBitmap()\r
+ splashStyle = wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT\r
+ splashDuration = 2000 # milliseconds\r
+ splashCallback = None\r
+ # Call the constructor with the above arguments in exactly the\r
+ # following order.\r
+ wx.SplashScreen.__init__(self, aBitmap, splashStyle,\r
+ splashDuration, None, -1)\r
+ wx.EVT_CLOSE(self, self.OnExit)\r
+ self.frame=frame\r
+ wx.Yield()\r
+\r
+ def OnExit(self, evt):\r
+ self.Hide()\r
+\r
+ self.frame.Show()\r
+ # The program will freeze without this line.\r
+ evt.Skip() # Make sure the default handler runs too...\r
+\r
+\r
+#------------------------------------------------------------------------------\r
+\r
+def main():\r
+\r
+ #save the directory where Hooke is located\r
+ config['hookedir']=os.getcwd()\r
+\r
+ #now change to the working directory.\r
+ try:\r
+ os.chdir(config['workdir'])\r
+ except OSError:\r
+ print "Warning: Invalid work directory."\r
+\r
+ app=wx.PySimpleApp()\r
+\r
+ def make_gui_class(*bases):\r
+ return type(MainWindow)("MainWindowPlugged", bases + (MainWindow,), {})\r
+\r
+ main_frame = make_gui_class(*GUI_PLUGINS)(None, -1, ('Hooke '+__version__))\r
+\r
+ #FIXME. The frame.Show() is called by the splashscreen here! Ugly as hell.\r
+\r
+ mysplash=MySplashScreen(main_frame)\r
+ mysplash.Show()\r
+\r
+ my_cmdline=CliThread(main_frame, list_of_events)\r
+ my_cmdline.start()\r
+\r
+\r
+ app.MainLoop()\r
+\r
+main()\r
projects / hooke.git / commitdiff