class Plot(wx.Panel):
def __init__(self, parent, id=-1, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
self.figure = mpl.figure.Figure(dpi=dpi, figsize=(12, 10))
self.canvas = Canvas(self, -1, self.figure)
self.l0 = wx.StaticText(self, -1, "Start at x=")
self.t0 = wx.TextCtrl(self, 3, style=wx.TE_PROCESS_ENTER)
#self.t0.SetRange(-1e10, 1e10)
self.t0.Bind(wx.EVT_TEXT_ENTER, self.onUpdateT0, id=3)
self.lv = wx.StaticText(self, -1, "")
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
sizer1 = wx.BoxSizer(wx.HORIZONTAL)
sizer1.Add(self.l0)
sizer1.Add(self.t0)
sizer1.Add(self.lv)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(sizer1, 1, wx.EXPAND)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
def setLV(self, lv, lvm):
self.lv.SetLabel(", last value = %g (mean %g)" % (lv, lvm))
def onUpdateT0(self, event):
x0 = float(self.t0.GetValue())
self.figure.gca().set_xlim(left=x0)
self.canvas.draw()
class Plot(wx.Panel):
def __init__(self, parent, id=-1, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
self.figure = mpl.figure.Figure(dpi=dpi, figsize=(2, 2))
self.canvas = Canvas(self, -1, self.figure)
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
class Plot(wx.Panel):
def __init__(self, parent, fig, id = -1, dpi = None, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
fig.set_figheight(2)
fig.set_figwidth(2)
self.canvas = Canvas(self, -1, fig)
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas,1,wx.EXPAND)
sizer.Add(self.toolbar, 0 , wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
class PlotPanel(wx.Panel):
"""
Panel with embedded matplotlib plots
"""
def __init__(self,parent):
wx.Panel.__init__(self,parent,-1)
self.fig = Figure(figsize=(2,2))
self.canvas = FigCanvas(self,-1,self.fig)
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
def __init__(self, *args, **kw):
wx.Panel.__init__(self, *args, **kw)
figure = Figure(figsize=(1, 1), dpi=72)
canvas = FigureCanvas(self, wx.ID_ANY, figure)
self.pylab_figure = PylabFigure(canvas)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(canvas)
mpl_toolbar.Realize()
# Create a vertical box sizer to manage the widgets in the main panel.
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(canvas, 1, wx.EXPAND | wx.LEFT | wx.RIGHT, border=0)
sizer.Add(mpl_toolbar, 0, wx.EXPAND | wx.ALL, border=0)
# Associate the sizer with its container.
self.SetSizer(sizer)
sizer.Fit(self)
def __init__(self, *args, **kw):
wx.Panel.__init__(self, *args, **kw)
# Instantiate a figure object that will contain our plots.
figure = Figure(figsize=(1, 1), dpi=72)
# Initialize the figure canvas, mapping the figure object to the plot
# engine backend.
canvas = FigureCanvas(self, wx.ID_ANY, figure)
# Wx-Pylab magic ...
# Make our canvas an active figure manager for pylab so that when
# pylab plotting statements are executed they will operate on our
# canvas and not create a new frame and canvas for display purposes.
# This technique allows this application to execute code that uses
# pylab stataments to generate plots and embed these plots in our
# application window(s). Use _activate_figure() to set.
self.pylab_interface = EmbeddedPylab(canvas)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(canvas)
mpl_toolbar.Realize()
# Create a vertical box sizer to manage the widgets in the main panel.
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(canvas, 1, wx.EXPAND | wx.LEFT | wx.RIGHT, border=0)
sizer.Add(mpl_toolbar, 0, wx.EXPAND | wx.ALL, border=0)
# Associate the sizer with its container.
self.SetSizer(sizer)
sizer.Fit(self)
self.view = Probe.view
self._need_redraw = False
self.Bind(wx.EVT_SHOW, self.OnShow)
self._calculating = False
self.toolbar = mpl_toolbar
def __init__(self,parent,id):
wx.Panel.__init__(self,parent,id,style=wx.BORDER_SUNKEN)
self.scale_collection = array([])
self.real_data = flipud(parent.data.T)
self.parent = parent
self.raw_data = flipud(parent.model.T)
self.scaled_data = copy(self.raw_data)
self.plot_extent = parent.plot_extent
lower_lim = amin(self.scaled_data[nonzero(self.scaled_data.real)])
finite_real = self.real_data[isfinite(self.real_data)]
finite_real = finite_real[nonzero(finite_real)]
#Hack
#self.vmin = amin(log(finite_real.real))
self.vmax = amax(log(finite_real.real))
self.vmin = self.vmax - 12
self.figure = Figure()
self.axes = self.figure.add_subplot(211)
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
self.myImage = self.showImage(log(abs(self.scaled_data)),self.axes)
self.modelColor = self.figure.colorbar(self.myImage)
self.dataaxes = self.figure.add_subplot(212)
self.datamyImage = self.showImage(log(self.real_data),self.dataaxes)
self.dataColor = self.figure.colorbar(self.datamyImage)
self.scale = wx.TextCtrl(self,-1)
self.updateButton = wx.Button(self,-1,'UPDATE')
self.resetButton = wx.Button(self,-1,'RESET')
self.areaScaleButton = wx.Button(self,-1,'AUTO SCALE')
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.scale,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.updateButton,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.resetButton,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.areaScaleButton,0,wx.LEFT|wx.RIGHT, border = 5)
vertSize.Add(self.canvas,-1,wx.EXPAND)
vertSize.Add(mpl_toolbar,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.updateButton.Bind(wx.EVT_BUTTON,self.update)
self.resetButton.Bind(wx.EVT_BUTTON,self.reset)
self.areaScaleButton.Bind(wx.EVT_BUTTON,self.autoScale)
class FigurePanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.SetBackgroundColour('#DCE5EE')
pub().subscribe(self.update_language, T.LANGUAGE_CHANGED)
self.control_panel = None
self.dframes = []
self.order_names = []
self.key_figure = 1
self.mode_run = False
self.current_dataframes = None
self.current_datacolors = None
self.run_explorer = False
self.figure_config_dialog_ref = None
# ---- inicialización de figura
self.fig = Figure()
self.canvas = FigureCanvas(self, -1, self.fig)
# ---- configuración de figura
self.fig_config = FigureConfig()
self.set_figure_config()
# ---- configuración de axe
self.ax_conf = AxesConfig()
# ---- radar chard config
self.radar_chard_con = RadarChadConfig()
# ---- toolbar
self.sizer_tool = wx.BoxSizer(wx.HORIZONTAL)
_bitmap = play_fig.GetBitmap()
self.b_play = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER)
self.sizer_tool.Add(self.b_play, flag=wx.ALIGN_CENTER_VERTICAL)
self.b_play.Bind(wx.EVT_BUTTON, self.on_play)
self.b_play.SetToolTipString(L('VISUALIZE_DATE_CLUSTER'))
_bitmap = settings_fig.GetBitmap()
self.b_setting = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER)
self.sizer_tool.Add(self.b_setting, flag=wx.ALIGN_CENTER_VERTICAL)
self.b_setting.Bind(wx.EVT_BUTTON, self.on_config)
self.b_setting.SetToolTipString(L('FIGURE_CONF'))
_bitmap = sort_and_filter.GetBitmap()
self.b_sorted = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER)
self.b_sorted.Bind(wx.EVT_BUTTON, self.on_sort_and_filter)
self.b_sorted.SetToolTipString(L('BUTTON_ORDER_AND_FILTER'))
self.b_sorted.Disable()
self.sizer_tool.Add(self.b_sorted, 0, wx.ALIGN_CENTER_VERTICAL)
_bp = line_highligh.GetBitmap()
self.b_highligh = wx.BitmapButton(self, -1, _bp, style=wx.NO_BORDER)
self.b_highligh.Bind(wx.EVT_BUTTON, self.on_highligh)
self.b_highligh.SetToolTipString(L('BUTTON_HIGHLIGHT'))
self.b_highligh.Disable()
self.sizer_tool.Add(self.b_highligh, 0, wx.ALIGN_CENTER_VERTICAL)
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
self.toolbar.SetBackgroundColour('#DCE5EE')
self.sizer_tool.Add(self.toolbar, 0, wx.ALIGN_CENTER_VERTICAL)
choice_grafic = self.get_choice_grafic()
self.sizer_tool.Add(choice_grafic, wx.ALIGN_LEFT)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.sizer_tool, 0, wx.EXPAND)
self.sizer.Add(self.canvas, 1, wx.EXPAND)
self.SetSizer(self.sizer)
self.Fit()
self._welcome()
def _welcome(self):
Axes3D(self.fig)
def set_figure_config(self):
self.fig.set_figwidth(self.fig_config.width)
self.fig.set_figheight(self.fig_config.height)
self.fig.set_facecolor(self.fig_config.facecolor)
left = self.fig_config.subplot_left
bottom = self.fig_config.subplot_bottom
right = self.fig_config.subplot_right
top = self.fig_config.subplot_top
wspace = self.fig_config.subplot_wspace
hspace = self.fig_config.subplot_hspace
self.fig.subplots_adjust(left, bottom, right, top, wspace, hspace)
self.fig.suptitle('Tava Tool',
fontsize=14,
fontweight='light',
style='italic',
family='serif',
color='c',
horizontalalignment='center',
verticalalignment='center')
def draw_graphic(self, dframes, colors):
key_figure = self.g_figure()
if key_figure == K_PARALLEL_COORDENATE:
return kparallelcoordinates(dframes, 'Name', self.fig,
self.ax_conf, self.fig_config, colors)
elif key_figure == K_RADAR_CHART_POLYGON:
return radarchart(dframes, 'Name', self.fig, self.ax_conf,
self.radar_chard_con, colors)
elif key_figure == K_RADVIZ:
return kradviz(dframes, 'Name', self.fig, self.ax_conf, colors)
def kdraw(self, dframes, colors, ldic):
self.current_dataframes = dframes
self.current_datacolors = colors
self.ldic = ldic
self._kdraw(dframes, colors)
def pre_kdraw_order(self, names_ordered):
names_ordered.append('Name')
_dframes = []
for df in self.current_dataframes:
_dframes.append(df[names_ordered])
self._kdraw(_dframes, self.current_datacolors)
def _kdraw(self, dframes, colors):
self.fig.clear()
self.start_busy()
task = DrawThread(self, dframes, colors)
task.start()
def on_play(self, event):
self.mode_run = True
self.run_explorer = True
self.new_order = []
# ---- dibujar clusters/datos seleccionados
self.control_panel.run_fig()
def on_sort_and_filter(self, event):
self.run_explorer = True
cdf = self.current_dataframes
if cdf is None or cdf == []:
return
self.old_order = cdf[0].columns.tolist()[:-1]
ItemsPickerFilterDialog(self, self.old_order)
def on_highligh(self, event):
_label_aux = ''
if self.run_explorer:
for axe in self.fig.get_axes():
lines = []
for line in axe.get_children():
if isinstance(line, Line2D):
if self.ldic.get(line.get_color()) is not None:
_label_aux = self.ldic.get(line.get_color())
line.set_label('shape = ' +
self.ldic.get(line.get_color()))
lines.append(line)
else:
line.set_label('')
h = resaltar(lines,
highlight_color=self.ax_conf.highlight_color,
formatter='{label}'.format)
if lines != []:
h.show_highlight(lines[0])
self.run_explorer = False
self.canvas_draw()
def on_config(self, event):
if self.figure_config_dialog_ref is None:
self.figure_config_dialog_ref = FigureConfigDialog(self)
else:
self.figure_config_dialog_ref.nb.SetSelection(0)
self.figure_config_dialog_ref.ShowModal()
def g_figure(self):
return self.ch_graph.GetSelection()
def get_choice_grafic(self):
grid = wx.FlexGridSizer(cols=2)
sampleList = self.get_item_list()
self.ch_graph = wx.Choice(self, -1, choices=sampleList)
self.ch_graph.SetSelection(0)
self.ch_graph.Bind(wx.EVT_CHOICE, self.on_graphic)
self.ch_graph.SetToolTipString(L('SELECT_A_GRAPHIC'))
grid.Add(self.ch_graph, 0, wx.ALIGN_LEFT | wx.ALL, 5)
return grid
def get_item_list(self):
return [L('PARALLEL_COORDINATES'), 'Radar Chart']
def on_graphic(self, event):
if event.GetString() != L('PARALLEL_COORDINATES') or not self.mode_run:
self.b_highligh.Disable()
return
self.b_highligh.Enable()
def update_language(self, msg):
s = self.ch_graph.GetSelection()
self.ch_graph.SetItems(self.get_item_list())
self.ch_graph.SetSelection(s)
self.ch_graph.SetToolTipString(L('SELECT_A_GRAPHIC'))
self.b_setting.SetToolTipString(L('FIGURE_CONF'))
self.b_play.SetToolTipString(L('VISUALIZE_DATE_CLUSTER'))
def start_busy(self):
pub().sendMessage(T.START_BUSY)
self.b_play.Disable()
self.toolbar.Disable()
self.b_setting.Disable()
self.ch_graph.Disable()
self.b_highligh.Disable()
self.b_sorted.Disable()
def stop_busy(self):
pub().sendMessage(T.STOP_BUSY)
self.b_play.Enable()
self.toolbar.Enable()
self.b_setting.Enable()
self.ch_graph.Enable()
self.b_highligh.Enable()
self.b_sorted.Enable()
def canvas_draw(self):
self.canvas.draw()
def set_fig(self, fig):
self.fig = fig
class MatplotlibPanel(wx.Panel):
def __init__(self, parent, id, data, minimum, maximum):
self.id = id
wx.Panel.__init__(self, parent, self.id, style=wx.SIMPLE_BORDER)
self.data = data
self.minimum = minimum
self.maximum = maximum
self.tooltip = wx.ToolTip(tip='Tip with a details of points')
self.SetToolTip(self.tooltip)
self.tooltip.Enable(True)
self.tooltip.SetDelay(0)
self.fig = plt.figure(self.id,
figsize=(12, 6.5),
dpi=100,
facecolor="w",
frameon=True)
self.canvas = FigureCanvas(self, self.id, self.fig)
self.toolbar = NavigationToolbar(self.canvas)
mass_txt = wx.StaticText(self.toolbar,
label='m/z',
pos=(230, 7),
size=(25, 17))
mass_txt.SetBackgroundColour("light gray")
self.mass = wx.TextCtrl(self.toolbar,
pos=(260, 4),
size=(50, 22),
style=wx.TE_READONLY)
self.toolbar.SetToolBitmapSize(wx.Size(24, 25))
self.toolbar.SetMinSize((1500, 40))
self.toolbar.Realize()
self.toolbar.Update()
self.fig.canvas.mpl_connect('button_press_event', self.onclick)
self.fig.canvas.mpl_connect('pick_event', self.on_pick)
self.fig.canvas.mpl_connect('motion_notify_event', self.on_motion)
self.fig.canvas.mpl_connect('key_press_event', self.on_key)
self.SetAutoLayout(True)
self.SetBackgroundColour('midnight blue')
# Now put all into a sizer
sizer = wx.BoxSizer(wx.VERTICAL)
# This way of adding to sizer allows resizing
sizer.Add(self.canvas, 5, wx.LEFT | wx.TOP | wx.GROW)
# Best to allow the toolbar to resize!
sizer.Add(self.toolbar, 0, wx.GROW)
self.SetSizer(sizer)
self.Fit()
print "matplotlib has been changed"
print "matplotlib panel class with id %s" % self.id
def onclick(self, event):
print "generated from onclick event This is X=%s and Y=%s" % (
event.xdata, event.ydata)
return
def on_pick(self, event):
print "Onpick called"
x_label = self.fig.axes[0].get_xlabel()
y_label = self.fig.axes[0].get_ylabel()
xdata, ydata = event.artist._offsets[:, 0], event.artist._offsets[:, 1]
self.x, self.y = np.take(xdata,
event.ind[0]), np.take(ydata, event.ind[0])
top = tip = '%s: %.2f\n%s: %.2f' % (x_label, self.x, y_label, self.y)
self.tooltip.SetTip(tip)
self.tooltip.Enable(True)
return
def on_motion(self, evt):
if evt.inaxes:
xpos = evt.xdata
self.mass.SetValue(' %0.1f' % (xpos))
def on_key(self, event):
if 'escape' == event.key:
self._is_pick_started = False
self._picked_indices = None
class ExplorerFrame(wx.Dialog):
ABORTED = -1
def __init__(self,
images,
parent=None,
id=wx.ID_ANY,
title='CellStar explorer',
x=900,
y=600):
"""
@type images: ImageRepo
"""
style = wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
wx.Dialog.__init__(self, parent, id, title, style=style)
self.Size = (x, y)
self.figure = mpl.figure.Figure(dpi=300, figsize=(1, 1))
self.axes = self.figure.add_subplot(111)
self.axes.margins(0, 0)
self.canvas = Canvas(self, -1, self.figure)
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
self.abort = False
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
self.layer0 = self.axes.imshow(images.image, cmap=mpl.cm.gray)
def onclick_internal(event):
if event.ydata is None:
return
print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f' % (
event.button, event.x, event.y, event.xdata, event.ydata)
if event.button != 1:
self.onclick(event.button, event.xdata, event.ydata)
self.figure.canvas.draw()
def press_internal(event):
print('press', event.key)
if event.key == 'b': # abort
self.EndModal(ExplorerFrame.ABORTED)
if event.key in 'qwerxcv':
self.layer0.remove()
if event.key == 'q': # input
self.layer0 = self.axes.imshow(images.image,
cmap=mpl.cm.gray)
elif event.key == 'w': # image clean
self.layer0 = self.axes.imshow(
images.image_back_difference, cmap=mpl.cm.gray)
elif event.key == 'x': # image clean
self.layer0 = self.axes.imshow(
images.image_back_difference_blurred, cmap=mpl.cm.gray)
elif event.key == 'c': # image clean
self.layer0 = self.axes.imshow(images.foreground_mask,
cmap=mpl.cm.gray)
elif event.key == 'v': # image clean
self.layer0 = self.axes.imshow(images.background_mask,
cmap=mpl.cm.gray)
elif event.key == 'e': # brighter
self.layer0 = self.axes.imshow(images.brighter,
cmap=mpl.cm.gray)
elif event.key == 'r': # darker
self.layer0 = self.axes.imshow(images.darker,
cmap=mpl.cm.gray)
self.figure.canvas.draw()
else:
self.press(event.key)
self.figure.canvas.draw()
self.figure.canvas.mpl_connect('button_press_event', onclick_internal)
self.figure.canvas.mpl_connect('key_press_event', press_internal)
self.Show(True)
def onclick(self, x, y):
pass
def __init__(self,frame,id):
wx.Panel.__init__(self,frame,id,style = wx.BORDER_RAISED)
z_layer = 0
self.omf = frame.omf
self.halfstep = (float(self.omf.parameters['zstepsize'])/2.0)*1.0e10
self.figure = Figure(frameon = True)
self.figure.set_facecolor('.82')
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
self.wheel_cmap = LinearSegmentedColormap.from_list('wheel_rgby',
['red', 'green', 'blue', 'yellow', 'red'])
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
x,y = indices((100,100), dtype = float) - 50.
wheel_angle = arctan2(x,y)
self.ax1 = self.figure.add_axes([0.1,0.1,0.7,0.8])
self.angle = ma.array(arctan2(-self.omf.my[:,:,z_layer],
self.omf.mx[:,:,z_layer]),
mask=(self.omf.M[:,:,z_layer] == 0.0))
self.angle[self.angle==360] = 0.0
print ma.getdata(self.angle)
xmax = (float(self.omf.parameters['xnodes']) *
float(self.omf.parameters['xstepsize']) * 1.0e10)
ymax = (float(self.omf.parameters['ynodes']) *
float(self.omf.parameters['ystepsize']) * 1.0e10)
self.extent = [0., xmax, 0., ymax]
self.im = self.ax1.imshow(self.angle.T, origin='lower',
interpolation = 'nearest',
extent = self.extent,
cmap = self.wheel_cmap,
vmin = -pi, vmax = pi)
self.ax1.set_title('Z Slice = ' +
str(z_layer*float(self.omf.parameters['zstepsize'])* 1.0e10
+ self.halfstep) +' Ang' ,size = 'xx-large')
self.ax1.set_xlabel('$x (\AA)$', size = 'x-large')
self.ax1.set_ylabel('$y (\AA)$', size = 'x-large')
self.ax1w = self.figure.add_axes([0.75,0.4,0.3,0.2], polar=True)
self.ax1w.yaxis.set_visible(False)
self.ax1w.imshow(wheel_angle, cmap=self.wheel_cmap,
extent=[0,2*pi,0,pi])
self.ax1w.set_title('M direction\n(in-plane)')
self.zselect = wx.Slider(self,-1,size = [300,40],minValue = int(0),
maxValue = int(self.omf.dims[2]-1),
style = wx.SL_AUTOTICKS)
self.datavalue = wx.StatusBar(self,-1)
self.datavalue.SetStatusText('Angle Value: ')
self.label = wx.StaticText(self,-1,'Select Z layer: ')
self.minVal = wx.StaticText(self,-1, '0.0')
self.maxVal = wx.StaticText(self,-1, str(self.omf.dims[2]*
(float(self.omf.parameters['zstepsize'])* 1.0e10)
-self.halfstep))
#Sizer Creation
toolSize = wx.BoxSizer(wx.HORIZONTAL)
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.label,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.minVal,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.zselect,0,wx.TOP|wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.maxVal,0,wx.LEFT|wx.RIGHT,border = 5)
toolSize.Add(mpl_toolbar,0,wx.RIGHT,border = 20)
toolSize.Add(self.datavalue,0,wx.LEFT|wx.RIGHT|wx.TOP,border = 20)
vertSize.Add(self.canvas,-1,wx.EXPAND|wx.LEFT|wx.RIGHT,border = 5)
vertSize.Add(toolSize,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.zselect.Bind(wx.EVT_SCROLL,self.newMomentZ)
self.canvas.mpl_connect('motion_notify_event',self.onMouseOver)
def __init__(self,frame,id):
wx.Panel.__init__(self,frame,id,style = wx.BORDER_RAISED)
self.v = frame.v
self.extent = frame.extent
self.step = frame.step
self.n = frame.n
z_layer = 0
self.halfstep = self.step[2]/2.0
self.figure = Figure(frameon = True)
self.figure.set_facecolor('.82')
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
self.ax1 = self.figure.add_axes([0.1,0.1,0.7,0.8])
plotExtent = ([self.extent[0,0],self.extent[0,1],
self.extent[1,0],self.extent[1,1]])
self.im = self.ax1.imshow(self.v[:,:,z_layer].T,
origin='lower',
interpolation = 'nearest',
extent = plotExtent,
vmin = amin(self.v),
vmax = amax(self.v))
self.ax1.set_title('Z Slice = ' +
str(z_layer *self.step[2] + self.halfstep) +
' Ang' ,size = 'xx-large')
self.figure.colorbar(self.im,format = '%.2e')
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
self.zselect = wx.Slider(self,-1,size = [300,40],minValue = int(0),
maxValue = int(self.n[2]-1),
style = wx.SL_AUTOTICKS)
print self.extent[2,1]
print self.halfstep
print 'TEST', str(self.extent[2,1] - self.halfstep)
self.label = wx.StaticText(self,-1,'Select Z layer: ')
self.minVal = wx.StaticText(self,-1, '0.0')
self.maxVal = wx.StaticText(self,-1, str(self.extent[2,1]
- self.halfstep))
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.label,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.minVal,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.zselect,0,wx.TOP|wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.maxVal,0,wx.LEFT|wx.RIGHT,border = 5)
vertSize.Add(self.canvas,-1,wx.EXPAND|wx.LEFT|wx.RIGHT)
vertSize.Add(mpl_toolbar,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.zselect.Bind(wx.EVT_SCROLL,self.newUnitZ)
class Plot(wx.Panel):
def __init__(self, parent, id=-1, dpi=None, toolbar=True, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
self.figure = matplotlib.figure.Figure(dpi=dpi,
facecolor=(0.9, 0.9, 0.9, 1))
self.canvas = Canvas(self, -1, self.figure)
self.plot_sizer = wx.BoxSizer(wx.VERTICAL)
if toolbar:
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
self.plot_sizer.Add(self.toolbar, 0,
wx.ALIGN_CENTER_VERTICAL | wx.EXPAND)
self.plot_sizer.Add(self.canvas, 1, wx.EXPAND)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.plot_sizer, 1, wx.EXPAND)
self.SetSizer(self.sizer)
self.setup_events()
#---------------------------------------------------------------------------
def setup_events(self):
self.mouse_down_x = None
self.mouse_down_y = None
self.mouse_up_x = None
self.mouse_up_y = None
self.pick_x = None
self.pick_y = None
self.set_event_handlers()
#---------------------------------------------------------------------------
def set_event_handlers(self):
"""wire up default mpl event handlers"""
events = (
("button_press_event", self.on_button_down),
("button_release_event", self.on_button_up),
("key_press_event", self.on_key_down),
("key_release_event", self.on_key_up),
("pick_event", self.on_pick),
("motion_notify_event", self.on_motion),
("scroll_event", self.on_scroll),
("idle_event", self.on_idle),
)
for event, handler in events:
self.figure.canvas.mpl_connect(event, handler)
#---------------------------------------------------------------------------
def on_button_down(self, event):
"""default button down handler"""
self.mouse_down_x = event.xdata
self.mouse_down_y = event.ydata
#---------------------------------------------------------------------------
def on_button_up(self, event):
"""default button up handler"""
self.mouse_up_x = event.xdata
self.mouse_up_y = event.ydata
#---------------------------------------------------------------------------
def on_pick(self, event):
"""default pick event"""
self.pick_x = event.mouseevent.xdata
self.pick_y = event.mouseevent.ydata
#---------------------------------------------------------------------------
def on_key_down(self, event):
"""default key down event"""
#---------------------------------------------------------------------------
def on_key_up(self, event):
"""default key up event"""
#---------------------------------------------------------------------------
def on_motion(self, event):
"""default mouse motion event"""
#---------------------------------------------------------------------------
def on_scroll(self, event):
"""default scroll event"""
#---------------------------------------------------------------------------
def on_idle(self, event):
"""default idle event"""
#---------------------------------------------------------------------------
def was_click(self):
"""check whether mouse down/up are coincident and therfore qualify as a click"""
if None in (self.mouse_down_x, self.mouse_down_y, self.mouse_up_x,
self.mouse_up_y):
return False
downs = (self.mouse_down_x, self.mouse_down_y)
ups = (self.mouse_up_x, self.mouse_up_y)
return numpy.allclose(downs, ups)
#---------------------------------------------------------------------------
def was_pick(self):
"""check if last click was an artist pick"""
if None in (self.pick_x, self.pick_y, self.mouse_up_x,
self.mouse_up_y):
return False
picks = (self.pick_x, self.pick_y)
ups = (self.mouse_up_x, self.mouse_up_y)
return numpy.allclose(picks, ups)
class Plot(wx.Frame):
def __init__(self, parent, id=-1, dpi=None, **kwargs):
# begin wxGlade: MyFrame.__init__
kwargs["style"] = wx.DEFAULT_FRAME_STYLE
kwargs["size"] = (600, 600)
wx.Frame.__init__(self, parent, id=id, **kwargs)
# create figure
self.figure = mpl.figure.Figure(dpi=dpi, figsize=(2, 2))
self.canvas = Canvas(self, -1, self.figure)
#self.toolbar = Toolbar(self.canvas)
#self.toolbar.Realize()
self.add_toolbar()
#self.axes = self.figure.gca()
self.PNL_AXES = wx.Panel(parent=self)
# additional controls
xAxisDataLabel = wx.StaticText(parent=self.PNL_AXES, label='X data:')
yAxisDataLabel = wx.StaticText(parent=self.PNL_AXES, label='Y data:')
self.xAxisData = wx.Choice(self.PNL_AXES)
self.yAxisData = wx.Choice(self.PNL_AXES)
self.xAxisScale = wx.Choice(self.PNL_AXES)
self.xAxisScale.AppendItems(["linear scale", "log10 scale"])
self.xAxisScale.Select(0)
self.yAxisScale = wx.Choice(self.PNL_AXES)
self.yAxisScale.AppendItems(["linear scale", "log10 scale"])
self.yAxisScale.Select(0)
axesPanelSizer = wx.FlexGridSizer(rows=0, cols=3, vgap=0, hgap=0)
axesPanelSizer.Add(xAxisDataLabel, 0, wx.LEFT)
axesPanelSizer.Add(self.xAxisData, 0, wx.LEFT)
axesPanelSizer.Add(self.xAxisScale, 0, wx.LEFT)
axesPanelSizer.Add(yAxisDataLabel, 0, wx.LEFT)
axesPanelSizer.Add(self.yAxisData, 0, wx.LEFT)
axesPanelSizer.Add(self.yAxisScale, 0, wx.LEFT)
self.PNL_AXES.SetSizer(axesPanelSizer)
self.PNL_AXES.SetAutoLayout(True)
axesPanelSizer.Fit(self.PNL_AXES)
axesPanelSizer.SetSizeHints(self.PNL_AXES)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
sizer.Add(self.PNL_AXES, 0, wx.LEFT | wx.EXPAND)
self.SetSizer(sizer)
self.Layout()
#self.__set_properties()
# couple the EVENTS
# self.Bind(wx.EVT_CHECKBOX, self.stop, self.check_run)
self.Bind(event=wx.EVT_CLOSE, handler=self.OnClose)
self.Bind(event=wx.EVT_CHOICE,
handler=self.OnSetXlabel,
source=self.xAxisData)
self.Bind(event=wx.EVT_CHOICE,
handler=self.OnSetYlabel,
source=self.yAxisData)
self.Bind(event=wx.EVT_CHOICE,
handler=self.OnSetXScale,
source=self.xAxisScale)
self.Bind(event=wx.EVT_CHOICE,
handler=self.OnSetYScale,
source=self.yAxisScale)
self.acquizitionRunning = True
# create queue instance for the plot handling:
self.plottingThread = Queue.Queue(1)
# create redrawing deamon who will eat the queue
self.backgndDraw = threading.Thread(target=self._redrawPlot)
self.backgndDraw.setDaemon(True)
self.backgndDraw.start()
self.getPoints = threading.Thread(target=self._checkData)
self.getPoints.setDaemon(True)
return
def add_toolbar(self):
self.toolbar = Toolbar(self.canvas)
self.toolbar.Realize()
if wx.Platform == '__WXMAC__':
# Mac platform (OSX 10.3, MacPython) does not seem to cope with
# having a toolbar in a sizer. This work-around gets the buttons
# back, but at the expense of having the toolbar at the top
self.SetToolBar(self.toolbar)
else:
# On Windows platform, default window size is incorrect, so set
# toolbar width to figure width.
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
# By adding toolbar in sizer, we are able to put it at the bottom
# of the frame - so appearance is closer to GTK version.
# As noted above, doesn't work for Mac.
self.toolbar.SetSize(wx.Size(fw, th))
#self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
# update the axes menu on the toolbar
self.toolbar.update()
def set_my_title(self, title):
# begin wxGlade: MyFrame.__set_properties
self.SetTitle(title)
axes = self.figure.gca()
axes.set_title(title, visible=True)
# end wxGlade
def bind_data(self, datastore):
self.datagram = datastore.get_datagram()
self.graphTitle = datastore.dataFileName[-50:]
self.set_my_title(self.graphTitle)
self.lastDataRow = 0
self.xAxisData.Clear()
self.xAxisData.AppendItems(self.datagram.extract_header())
self.xAxisData.Select(0)
self.xIndex = self.xAxisData.GetStringSelection()
self.yAxisData.Clear()
self.yAxisData.AppendItems(self.datagram.extract_header())
self.yAxisData.Select(0)
self.yIndex = self.yAxisData.GetStringSelection()
#self.timer.start()
# update the axis label
axes = self.figure.gca()
axes.set_ylabel(self.yIndex, visible=True)
axes.set_xlabel(self.xIndex, visible=True)
def start_acquizition(self):
self.acquizitionRunning = True
self.getPoints.start()
def _checkData(self):
"""
periodically check for new data acquired
"""
while self.acquizitionRunning:
currentRow = self.datagram.get_current_data_row()
if currentRow > self.lastDataRow:
xFrom = 0
xTo = currentRow
try:
self.plottingThread.put(item=(xFrom, xTo),
block=False,
timeout=0)
except:
pass
time.sleep(0.1)
def reloadData(self, xFrom=0, xTo=None):
# which axes to plot in?
axes = self.figure.gca()
axes.clear()
# get data:
index = self.datagram.extract_data(key=self.xIndex,
from_to=(xFrom, xTo))
# check the scales:
xScale = self.xAxisScale.GetStringSelection()
if xScale == "log10 scale":
index = log10(abs(index))
axes.set_xlabel(('(log10(abs( %s ))' % self.xIndex), visible=True)
if xScale == "linear scale":
axes.set_xlabel(self.xIndex, visible=True)
values = self.datagram.extract_data(key=self.yIndex,
from_to=(xFrom, xTo))
# check the scales:
yScale = self.yAxisScale.GetStringSelection()
if yScale == "log10 scale":
values = log10(abs(values))
axes.set_ylabel(('(log10(abs( %s ))' % self.yIndex), visible=True)
if yScale == "linear scale":
axes.set_ylabel(self.yIndex, visible=True)
# plot and show the graph
axes.set_title(self.graphTitle, visible=True)
axes.scatter(
index,
values,
s=10,
c='r',
marker='+',
)
axes.autoscale_view()
self.canvas.draw()
def _redrawPlot(self):
while self.acquizitionRunning:
(xFrom,
xTo) = self.plottingThread.get(block=True) # obtain data to plot
self.reloadData(xFrom, xTo)
#self.timer.start()
time.sleep(0.1)
def OnClose(self, event):
self.Show(False)
return
def OnPaint(self, event):
self.canvas.draw()
return
def OnSetXlabel(self, event):
self.xIndex = event.GetString()
# update the axis label
#axes = self.figure.gca()
#axes.set_xlabel(self.xIndex,visible=True)
if not self.acquizitionRunning:
self.reloadData()
return
def OnSetYlabel(self, event):
self.yIndex = event.GetString()
# update the axis label
#axes = self.figure.gca()
#axes.set_ylabel(self.yIndex,visible=True)
if not self.acquizitionRunning:
self.reloadData()
return
def OnSetXScale(self, event):
scale = event.GetString()
# update the axis label
#axes = self.figure.gca()
#axes.set_xlabel(self.xIndex,visible=True)
if not self.acquizitionRunning:
self.reloadData()
return
def OnSetYScale(self, event):
scale = event.GetString()
# update the axis label
#axes = self.figure.gca()
#axes.set_ylabel(self.yIndex,visible=True)
if not self.acquizitionRunning:
self.reloadData()
return
