Plotter2D.py @ a2573fc

Last change on this file since a2573fc was 9a5097c, checked in by andyfaff, 8 years ago
MAINT: import numpy as np
Property mode set to `100644`
File size: 29.4 KB

Line
1
2	################################################################################
3	#This software was developed by the University of Tennessee as part of the
4	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
5	#project funded by the US National Science Foundation.
6	#
7	#See the license text in license.txt
8	#
9	#copyright 2008, University of Tennessee
10	################################################################################
11
12
13	import wx
14	import sys
15	import math
16	import numpy as np
17	import logging
18	from sas.sasgui.plottools.PlotPanel import PlotPanel
19	from sas.sasgui.plottools.plottables import Graph
20	from sas.sasgui.plottools.TextDialog import TextDialog
21	from sas.sasgui.guiframe.events import StatusEvent
22	from sas.sasgui.guiframe.events import NewPlotEvent
23	from sas.sasgui.guiframe.events import PanelOnFocusEvent
24	from sas.sasgui.guiframe.events import SlicerEvent
25	from sas.sasgui.guiframe.utils import PanelMenu
26	from sas.sasgui.guiframe.local_perspectives.plotting.binder import BindArtist
27	from Plotter1D import ModelPanel1D
28	from sas.sasgui.plottools.toolbar import NavigationToolBar
29	from matplotlib.font_manager import FontProperties
30	from graphAppearance import graphAppearance
31	(InternalEvent, EVT_INTERNAL) = wx.lib.newevent.NewEvent()
32
33	DEFAULT_QMAX = 0.05
34	DEFAULT_QSTEP = 0.001
35	DEFAULT_BEAM = 0.005
36	BIN_WIDTH = 1.0
37
38
39	def find_key(dic, val):
40	"""return the key of dictionary dic given the value"""
41	return [k for k, v in dic.iteritems() if v == val][0]
42
43
44	class NavigationToolBar2D(NavigationToolBar):
45	"""
46	"""
47	def __init__(self, canvas, parent=None):
48	NavigationToolBar.__init__(self, canvas=canvas, parent=parent)
49
50	def delete_option(self):
51	"""
52	remove default toolbar item
53	"""
54	#delete reset button
55	self.DeleteToolByPos(0)
56	#delete dragging
57	self.DeleteToolByPos(2)
58	#delete unwanted button that configures subplot parameters
59	self.DeleteToolByPos(4)
60
61	def add_option(self):
62	"""
63	add item to the toolbar
64	"""
65	#add button
66	id_context = wx.NewId()
67	context_tip = 'Graph Menu'
68	context = wx.ArtProvider.GetBitmap(wx.ART_LIST_VIEW, wx.ART_TOOLBAR)
69	self.InsertSimpleTool(0, id_context, context, context_tip, context_tip)
70	wx.EVT_TOOL(self, id_context, self.parent.onToolContextMenu)
71	self.InsertSeparator(1)
72	#add print button
73	id_print = wx.NewId()
74	print_bmp = wx.ArtProvider.GetBitmap(wx.ART_PRINT, wx.ART_TOOLBAR)
75	self.AddSimpleTool(id_print, print_bmp, 'Print', 'Activate printing')
76	wx.EVT_TOOL(self, id_print, self.on_print)
77
78
79	class ModelPanel2D(ModelPanel1D):
80	"""
81	Plot panel for use with the GUI manager
82	"""
83
84	## Internal name for the AUI manager
85	window_name = "plotpanel"
86	## Title to appear on top of the window
87	window_caption = "Plot Panel"
88	## Flag to tell the GUI manager that this panel is not
89	# tied to any perspective
90	ALWAYS_ON = True
91	## Group ID
92	group_id = None
93
94
95	def __init__(self, parent, id=-1, data2d=None, color=None,
96	dpi=None, style=wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs):
97	"""
98	Initialize the panel
99	"""
100	ModelPanel1D.__init__(self, parent, id=id, style=style, **kwargs)
101	self.parent = parent
102	## Reference to the parent window
103	if hasattr(parent, "parent"):
104	self.parent = self.parent.parent
105	## Dictionary containing Plottables
106	self.plots = {}
107	## Save reference of the current plotted
108	self.data2D = data2d
109	## Unique ID (from gui_manager)
110	self.uid = None
111	## Action IDs for internal call-backs
112	self.action_ids = {}
113	## Create Artist and bind it
114	self.connect = BindArtist(self.subplot.figure)
115	## Beam stop
116	self.beamstop_radius = DEFAULT_BEAM
117	## to set the order of lines drawn first.
118	self.slicer_z = 5
119	## Reference to the current slicer
120	self.slicer = None
121	## event to send slicer info
122	self.Bind(EVT_INTERNAL, self._onEVT_INTERNAL)
123
124	self.axes_frozen = False
125	## panel that contains result from slicer motion (ex: Boxsum info)
126	self.panel_slicer = None
127	self.title_label = None
128	self.title_font = None
129	self.title_color = 'black'
130	## Graph
131	self.graph = Graph()
132	self.graph.xaxis("\\rm{Q}", 'A^{-1}')
133	self.graph.yaxis("\\rm{Intensity} ", "cm^{-1}")
134	self.graph.render(self)
135	## store default value of zmin and zmax
136	self.default_zmin_ctl = self.zmin_2D
137	self.default_zmax_ctl = self.zmax_2D
138
139	def on_plot_qrange(self, event=None):
140	"""
141	On Qmin Qmax vertical line event
142	"""
143	# Not implemented
144	if event == None:
145	return
146	event.Skip()
147
148	def onLeftDown(self, event):
149	"""
150	left button down and ready to drag
151
152	"""
153	# Check that the LEFT button was pressed
154	PlotPanel.onLeftDown(self, event)
155	ax = event.inaxes
156	if ax != None:
157	# data coordinate position
158	pos_x = "%8.3g" % event.xdata
159	pos_y = "%8.3g" % event.ydata
160	position = "x: %s y: %s" % (pos_x, pos_y)
161	wx.PostEvent(self.parent, StatusEvent(status=position))
162	self.plottable_selected(self.data2D.id)
163	self._manager.set_panel_on_focus(self)
164	wx.PostEvent(self.parent, PanelOnFocusEvent(panel=self))
165
166	def add_toolbar(self):
167	"""
168	add toolbar
169	"""
170	self.enable_toolbar = True
171	self.toolbar = NavigationToolBar2D(parent=self, canvas=self.canvas)
172	self.toolbar.Realize()
173	# On Windows platform, default window size is incorrect, so set
174	# toolbar width to figure width.
175	_, th = self.toolbar.GetSizeTuple()
176	fw, _ = self.canvas.GetSizeTuple()
177	self.toolbar.SetSize(wx.Size(fw, th))
178	self.sizer.Add(self.toolbar, 0, wx.LEFT \| wx.EXPAND)
179	# update the axes menu on the toolbar
180	self.toolbar.update()
181
182	def plot_data(self, data):
183	"""
184	Data is ready to be displayed
185
186	:TODO: this name should be changed to something more appropriate
187	Don't forget that changing this name will mean changing code
188	in plotting.py
189
190	:param event: data event
191	"""
192	xlo = None
193	xhi = None
194	ylo = None
195	yhi = None
196	if data.__class__.__name__ == 'Data1D':
197	return
198	## Update self.data2d with the current plot
199	self.data2D = data
200	if data.id in self.plots.keys():
201	#replace
202	xlo, xhi = self.subplot.get_xlim()
203	ylo, yhi = self.subplot.get_ylim()
204	self.graph.replace(data)
205	self.plots[data.id] = data
206	else:
207	self.plots[data.id] = data
208	self.graph.add(self.plots[data.id])
209	# update qmax with the new xmax of data plotted
210	self.qmax = data.xmax
211	self.slicer = None
212	# Check axis labels
213	#TODO: Should re-factor this
214	## render the graph with its new content
215	#data2D: put 'Pixel (Number)' for axis title and unit in case of having no detector info and none in _units
216	if len(data.detector) < 1:
217	if len(data._xunit) < 1 and len(data._yunit) < 1:
218	data._xaxis = '\\rm{x}'
219	data._yaxis = '\\rm{y}'
220	data._xunit = 'pixel'
221	data._yunit = 'pixel'
222	# graph properties
223	self.graph.xaxis(data._xaxis, data._xunit)
224	self.graph.yaxis(data._yaxis, data._yunit)
225	if self._is_changed_legend_label:
226	data.label = self.title_label
227	if data.label == None:
228	data.label = data.name
229	if not self.title_font:
230	self.graph.title(data.label)
231	self.graph.render(self)
232	# Set the axis labels on subplot
233	self._set_axis_labels()
234	self.draw_plot()
235	else:
236	self.graph.render(self)
237	self.draw_plot()
238	self.subplot.set_title(label=data.label,
239	fontproperties=self.title_font,
240	color=self.title_color)
241	self.subplot.figure.canvas.draw_idle()
242	## store default value of zmin and zmax
243	self.default_zmin_ctl = self.zmin_2D
244	self.default_zmax_ctl = self.zmax_2D
245	if not self.is_zoomed:
246	return
247	# Recover the x,y limits
248	if xlo and xhi and ylo and yhi:
249	if xlo > data.xmin and xhi < data.xmax and \
250	ylo > data.ymin and yhi < data.ymax:
251	self.subplot.set_xlim((xlo, xhi))
252	self.subplot.set_ylim((ylo, yhi))
253	else:
254	self.toolbar.update()
255	self.is_zoomed = False
256
257	def _set_axis_labels(self):
258	"""
259	Set axis labels
260	"""
261	data = self.data2D
262	# control axis labels from the panel itself
263	yname, yunits = data.get_yaxis()
264	if self.yaxis_label != None:
265	yname = self.yaxis_label
266	yunits = self.yaxis_unit
267	else:
268	self.yaxis_label = yname
269	self.yaxis_unit = yunits
270	xname, xunits = data.get_xaxis()
271	if self.xaxis_label != None:
272	xname = self.xaxis_label
273	xunits = self.xaxis_unit
274	else:
275	self.xaxis_label = xname
276	self.xaxis_unit = xunits
277	self.xaxis(xname, xunits, self.xaxis_font,
278	self.xaxis_color, self.xaxis_tick)
279	self.yaxis(yname, yunits, self.yaxis_font,
280	self.yaxis_color, self.yaxis_tick)
281
282	def onContextMenu(self, event):
283	"""
284	2D plot context menu
285
286	:param event: wx context event
287
288	"""
289	ids = iter(self._menu_ids)
290	slicerpop = PanelMenu()
291	slicerpop.set_plots(self.plots)
292	slicerpop.set_graph(self.graph)
293
294	wx_id = ids.next()
295	slicerpop.Append(wx_id, '&Save Image', 'Save image as png')
296	wx.EVT_MENU(self, wx_id, self.onSaveImage)
297
298	wx_id = ids.next()
299	slicerpop.Append(wx_id, '&Print Image', 'Print image')
300	wx.EVT_MENU(self, wx_id, self.onPrint)
301
302	wx_id = ids.next()
303	slicerpop.Append(wx_id, '&Copy to Clipboard', 'Copy to the clipboard')
304	wx.EVT_MENU(self, wx_id, self.OnCopyFigureMenu)
305	slicerpop.AppendSeparator()
306	# saving data
307	plot = self.data2D
308	wx_id = ids.next()
309	slicerpop.Append(wx_id, "&Data Info")
310	wx.EVT_MENU(self, wx_id, self._onDataShow)
311
312	wx_id = ids.next()
313	slicerpop.Append(wx_id, "&Save as a File (DAT)")
314	self.action_ids[str(wx_id)] = plot
315	wx.EVT_MENU(self, wx_id, self._onSave)
316
317	slicerpop.AppendSeparator()
318	if len(self.data2D.detector) <= 1:
319	item_list = self.parent.get_current_context_menu(self)
320	if (not item_list == None) and (not len(item_list) == 0) and\
321	self.data2D.name.split(" ")[0] != 'Residuals':
322	for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]):
323	try:
324	slicerpop.Append(wx_id, item[0], item[1])
325	wx.EVT_MENU(self, wx_id, item[2])
326	except:
327	msg = "ModelPanel1D.onContextMenu: "
328	msg += "bad menu item %s" % sys.exc_value
329	wx.PostEvent(self.parent, StatusEvent(status=msg))
330	slicerpop.AppendSeparator()
331
332	wx_id = ids.next()
333	slicerpop.Append(wx_id, '&Perform Circular Average')
334	wx.EVT_MENU(self, wx_id, self.onCircular) \
335	# For Masked Data
336	if not plot.mask.all():
337	wx_id = ids.next()
338	slicerpop.Append(wx_id, '&Masked Circular Average')
339	wx.EVT_MENU(self, wx_id, self.onMaskedCircular)
340	wx_id = ids.next()
341	slicerpop.Append(wx_id, '&Sector [Q View]')
342	wx.EVT_MENU(self, wx_id, self.onSectorQ)
343	wx_id = ids.next()
344	slicerpop.Append(wx_id, '&Annulus [Phi View ]')
345	wx.EVT_MENU(self, wx_id, self.onSectorPhi)
346	wx_id = ids.next()
347	slicerpop.Append(wx_id, '&Box Sum')
348	wx.EVT_MENU(self, wx_id, self.onBoxSum)
349	wx_id = ids.next()
350	slicerpop.Append(wx_id, '&Box Averaging in Qx')
351	wx.EVT_MENU(self, wx_id, self.onBoxavgX)
352	wx_id = ids.next()
353	slicerpop.Append(wx_id, '&Box Averaging in Qy')
354	wx.EVT_MENU(self, wx_id, self.onBoxavgY)
355	if self.slicer != None:
356	wx_id = ids.next()
357	slicerpop.Append(wx_id, '&Clear Slicer')
358	wx.EVT_MENU(self, wx_id, self.onClearSlicer)
359	if self.slicer.__class__.__name__ != "BoxSum":
360	wx_id = ids.next()
361	slicerpop.Append(wx_id, '&Edit Slicer Parameters')
362	wx.EVT_MENU(self, wx_id, self._onEditSlicer)
363	slicerpop.AppendSeparator()
364
365	wx_id = ids.next()
366	slicerpop.Append(wx_id, '&Edit Graph Label', 'Edit Graph Label')
367	wx.EVT_MENU(self, wx_id, self.onEditLabels)
368	slicerpop.AppendSeparator()
369
370	# ILL mod here
371
372	wx_id = ids.next()
373	slicerpop.Append(wx_id, '&Modify graph appearance', 'Modify graph appearance')
374	wx.EVT_MENU(self, wx_id, self.modifyGraphAppearance)
375	slicerpop.AppendSeparator()
376
377	wx_id = ids.next()
378	slicerpop.Append(wx_id, '&2D Color Map')
379	wx.EVT_MENU(self, wx_id, self._onEditDetector)
380	slicerpop.AppendSeparator()
381
382	wx_id = ids.next()
383	slicerpop.Append(wx_id, '&Toggle Linear/Log Scale')
384	wx.EVT_MENU(self, wx_id, self._onToggleScale)
385
386	slicerpop.AppendSeparator()
387	wx_id = ids.next()
388	slicerpop.Append(wx_id, '&Window Title')
389	wx.EVT_MENU(self, wx_id, self.onChangeCaption)
390
391	try:
392	pos_evt = event.GetPosition()
393	pos = self.ScreenToClient(pos_evt)
394	except:
395	pos_x, pos_y = self.toolbar.GetPositionTuple()
396	pos = (pos_x, pos_y + 5)
397	self.PopupMenu(slicerpop, pos)
398
399	def onEditLabels(self, event):
400	"""
401	Edit legend label
402	"""
403	try:
404	selected_plot = self.plots[self.graph.selected_plottable]
405	except:
406	selected_plot = self.plots[self.data2D.id]
407	label = selected_plot.label
408	dial = TextDialog(None, -1, 'Change Label', label)
409	if dial.ShowModal() == wx.ID_OK:
410	try:
411	FONT = FontProperties()
412	newlabel = dial.getText()
413	font = FONT.copy()
414	font.set_size(dial.getSize())
415	font.set_family(dial.getFamily())
416	font.set_style(dial.getStyle())
417	font.set_weight(dial.getWeight())
418	colour = dial.getColor()
419	if len(newlabel) > 0:
420	# update Label
421	selected_plot.label = newlabel
422	self.graph.title(newlabel)
423	self.title_label = selected_plot.label
424	self.title_font = font
425	self.title_color = colour
426	## render the graph
427	self.subplot.set_title(label=self.title_label,
428	fontproperties=self.title_font,
429	color=self.title_color)
430	self._is_changed_legend_label = True
431	self.subplot.figure.canvas.draw_idle()
432	except:
433	msg = "Add Text: Error. Check your property values..."
434	logging.error(msg)
435	if self.parent != None:
436	wx.PostEvent(self.parent, StatusEvent(status=msg))
437	dial.Destroy()
438
439	def _onEditDetector(self, event):
440	"""
441	Allow to view and edits detector parameters
442
443	:param event: wx.menu event
444
445	"""
446	import detector_dialog
447	dialog = detector_dialog.DetectorDialog(self, -1, base=self.parent,
448	reset_zmin_ctl=self.default_zmin_ctl,
449	reset_zmax_ctl=self.default_zmax_ctl, cmap=self.cmap)
450	## info of current detector and data2D
451	xnpts = len(self.data2D.x_bins)
452	ynpts = len(self.data2D.y_bins)
453	xmax = max(self.data2D.xmin, self.data2D.xmax)
454	ymax = max(self.data2D.ymin, self.data2D.ymax)
455	qmax = math.sqrt(math.pow(xmax, 2) + math.pow(ymax, 2))
456	## set dialog window content
457	dialog.setContent(xnpts=xnpts, ynpts=ynpts, qmax=qmax,
458	beam=self.data2D.xmin,
459	zmin=self.zmin_2D,
460	zmax=self.zmax_2D)
461	if dialog.ShowModal() == wx.ID_OK:
462	evt = dialog.getContent()
463	self.zmin_2D = evt.zmin
464	self.zmax_2D = evt.zmax
465	self.cmap = evt.cmap
466	dialog.Destroy()
467	## Redraw the current image
468	self.image(data=self.data2D.data,
469	qx_data=self.data2D.qx_data,
470	qy_data=self.data2D.qy_data,
471	xmin=self.data2D.xmin,
472	xmax=self.data2D.xmax,
473	ymin=self.data2D.ymin,
474	ymax=self.data2D.ymax,
475	zmin=self.zmin_2D,
476	zmax=self.zmax_2D,
477	cmap=self.cmap,
478	color=0, symbol=0, label=self.data2D.name)
479	self.subplot.figure.canvas.draw_idle()
480
481	def freeze_axes(self):
482	"""
483	"""
484	self.axes_frozen = True
485
486	def thaw_axes(self):
487	"""
488	"""
489	self.axes_frozen = False
490
491	def onMouseMotion(self, event):
492	"""
493	"""
494	pass
495
496	def onWheel(self, event):
497	"""
498	"""
499	pass
500
501	def update(self, draw=True):
502	"""
503	Respond to changes in the model by recalculating the
504	profiles and resetting the widgets.
505	"""
506	self.draw_plot()
507
508	def _getEmptySlicerEvent(self):
509	"""
510	create an empty slicervent
511	"""
512	return SlicerEvent(type=None, params=None, obj_class=None)
513
514	def _onEVT_INTERNAL(self, event):
515	"""
516	Draw the slicer
517
518	:param event: wx.lib.newevent (SlicerEvent) containing slicer
519	parameter
520
521	"""
522	self._setSlicer(event.slicer)
523
524	def _setSlicer(self, slicer):
525	"""
526	Clear the previous slicer and create a new one.Post an internal
527	event.
528
529	:param slicer: slicer class to create
530
531	"""
532	## Clear current slicer
533	if not self.slicer == None:
534	self.slicer.clear()
535	## Create a new slicer
536	self.slicer_z += 1
537	self.slicer = slicer(self, self.subplot, zorder=self.slicer_z)
538	self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax)
539	self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax)
540	## Draw slicer
541	self.update()
542	self.slicer.update()
543	msg = "Plotter2D._setSlicer %s" % self.slicer.__class__.__name__
544	wx.PostEvent(self.parent, StatusEvent(status=msg))
545	# Post slicer event
546	event = self._getEmptySlicerEvent()
547	event.type = self.slicer.__class__.__name__
548	event.obj_class = self.slicer.__class__
549	event.params = self.slicer.get_params()
550	wx.PostEvent(self, event)
551
552	def onMaskedCircular(self, event):
553	"""
554	perform circular averaging on Data2D with mask if it exists
555
556	:param event: wx.menu event
557
558	"""
559	self.onCircular(event, True)
560
561	def onCircular(self, event, ismask=False):
562	"""
563	perform circular averaging on Data2D
564
565	:param event: wx.menu event
566
567	"""
568	# Find the best number of bins
569	npt = math.sqrt(len(self.data2D.data[np.isfinite(self.data2D.data)]))
570	npt = math.floor(npt)
571	from sas.sascalc.dataloader.manipulations import CircularAverage
572	## compute the maximum radius of data2D
573	self.qmax = max(math.fabs(self.data2D.xmax),
574	math.fabs(self.data2D.xmin))
575	self.ymax = max(math.fabs(self.data2D.ymax),
576	math.fabs(self.data2D.ymin))
577	self.radius = math.sqrt(math.pow(self.qmax, 2) + math.pow(self.ymax, 2))
578	##Compute beam width
579	bin_width = (self.qmax + self.qmax) / npt
580	## Create data1D circular average of data2D
581	Circle = CircularAverage(r_min=0, r_max=self.radius,
582	bin_width=bin_width)
583	circ = Circle(self.data2D, ismask=ismask)
584	from sas.sasgui.guiframe.dataFitting import Data1D
585	if hasattr(circ, "dxl"):
586	dxl = circ.dxl
587	else:
588	dxl = None
589	if hasattr(circ, "dxw"):
590	dxw = circ.dxw
591	else:
592	dxw = None
593
594	new_plot = Data1D(x=circ.x, y=circ.y, dy=circ.dy, dx=circ.dx)
595	new_plot.dxl = dxl
596	new_plot.dxw = dxw
597	new_plot.name = "Circ avg " + self.data2D.name
598	new_plot.source = self.data2D.source
599	#new_plot.info = self.data2D.info
600	new_plot.interactive = True
601	new_plot.detector = self.data2D.detector
602
603	## If the data file does not tell us what the axes are, just assume...
604	new_plot.xaxis("\\rm{Q}", "A^{-1}")
605	if hasattr(self.data2D, "scale") and \
606	self.data2D.scale == 'linear':
607	new_plot.ytransform = 'y'
608	new_plot.yaxis("\\rm{Residuals} ", "normalized")
609	else:
610	new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}")
611
612	new_plot.group_id = "2daverage" + self.data2D.name
613	new_plot.id = "Circ avg " + self.data2D.name
614	new_plot.is_data = True
615	self.parent.update_theory(data_id=self.data2D.id, \
616	theory=new_plot)
617	wx.PostEvent(self.parent,
618	NewPlotEvent(plot=new_plot, title=new_plot.name))
619
620	def _onEditSlicer(self, event):
621	"""
622	Is available only when a slicer is drawn.Create a dialog
623	window where the user can enter value to reset slicer
624	parameters.
625
626	:param event: wx.menu event
627
628	"""
629	if self.slicer != None:
630	from SlicerParameters import SlicerParameterPanel
631	dialog = SlicerParameterPanel(self, -1, "Slicer Parameters")
632	dialog.set_slicer(self.slicer.__class__.__name__,
633	self.slicer.get_params())
634	if dialog.ShowModal() == wx.ID_OK:
635	dialog.Destroy()
636
637	def onSectorQ(self, event):
638	"""
639	Perform sector averaging on Q and draw sector slicer
640	"""
641	from SectorSlicer import SectorInteractor
642	self.onClearSlicer(event)
643	wx.PostEvent(self, InternalEvent(slicer=SectorInteractor))
644
645	def onSectorPhi(self, event):
646	"""
647	Perform sector averaging on Phi and draw annulus slicer
648	"""
649	from AnnulusSlicer import AnnulusInteractor
650	self.onClearSlicer(event)
651	wx.PostEvent(self, InternalEvent(slicer=AnnulusInteractor))
652
653	def onBoxSum(self, event):
654	"""
655	"""
656	from sas.sasgui.guiframe.gui_manager import MDIFrame
657	from boxSum import BoxSum
658	self.onClearSlicer(event)
659	self.slicer_z += 1
660	self.slicer = BoxSum(self, self.subplot, zorder=self.slicer_z)
661	self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax)
662	self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax)
663	self.update()
664	self.slicer.update()
665	## Value used to initially set the slicer panel
666	params = self.slicer.get_params()
667	## Create a new panel to display results of summation of Data2D
668	from slicerpanel import SlicerPanel
669	win = MDIFrame(self.parent, None, 'None', (100, 200))
670	new_panel = SlicerPanel(parent=win, id=-1,
671	base=self, type=self.slicer.__class__.__name__,
672	params=params, style=wx.RAISED_BORDER)
673
674	new_panel.window_caption = self.slicer.__class__.__name__ + " " + \
675	str(self.data2D.name)
676	new_panel.window_name = self.slicer.__class__.__name__ + " " + \
677	str(self.data2D.name)
678	## Store a reference of the new created panel
679
680	## save the window_caption of the new panel in the current slicer
681	self.slicer.set_panel_name(name=new_panel.window_caption)
682	## post slicer panel to guiframe to display it
683	from sas.sasgui.guiframe.events import SlicerPanelEvent
684
685	win.set_panel(new_panel)
686	new_panel.frame = win
687	wx.PostEvent(self.parent, SlicerPanelEvent(panel=new_panel,
688	main_panel=self))
689	wx.CallAfter(new_panel.frame.Show)
690	self.panel_slicer = new_panel
691
692	def onBoxavgX(self, event):
693	"""
694	Perform 2D data averaging on Qx
695	Create a new slicer .
696
697	:param event: wx.menu event
698	"""
699	from boxSlicer import BoxInteractorX
700	self.onClearSlicer(event)
701	wx.PostEvent(self, InternalEvent(slicer=BoxInteractorX))
702
703	def onBoxavgY(self, event):
704	"""
705	Perform 2D data averaging on Qy
706	Create a new slicer .
707
708	:param event: wx.menu event
709
710	"""
711	from boxSlicer import BoxInteractorY
712	self.onClearSlicer(event)
713	wx.PostEvent(self, InternalEvent(slicer=BoxInteractorY))
714
715	def onClearSlicer(self, event):
716	"""
717	Clear the slicer on the plot
718	"""
719	if not self.slicer == None:
720	self.slicer.clear()
721	self.subplot.figure.canvas.draw()
722	self.slicer = None
723	# Post slicer None event
724	event = self._getEmptySlicerEvent()
725	wx.PostEvent(self, event)
726
727	def _onSave(self, evt):
728	"""
729	Save a data set to a dat(text) file
730
731	:param evt: Menu event
732
733	"""
734	event_id = str(evt.GetId())
735	if self.parent != None:
736	self._default_save_location = self.parent._default_save_location
737	default_name = self.plots[self.graph.selected_plottable].label
738	if default_name.count('.') > 0:
739	default_name = default_name.split('.')[0]
740	default_name += "_out"
741	if event_id in self.action_ids:
742	self.parent.save_data2d(self.data2D, default_name)
743
744	def _onDataShow(self, evt):
745	"""
746	Show the data set in text
747
748	:param evt: Menu event
749
750	"""
751	menu = evt.GetEventObject()
752	event_id = evt.GetId()
753	self.set_selected_from_menu(menu, event_id)
754	data = self.plots[self.graph.selected_plottable]
755	default_name = data.label
756	if default_name.count('.') > 0:
757	default_name = default_name.split('.')[0]
758	#default_name += "_out"
759	if self.parent != None:
760	self.parent.show_data2d(data, default_name)
761
762	def modifyGraphAppearance(self, e):
763	self.graphApp = graphAppearance(self, 'Modify graph appearance', legend=False)
764	self.graphApp.setDefaults(self.grid_on, self.legend_on,
765	self.xaxis_label, self.yaxis_label,
766	self.xaxis_unit, self.yaxis_unit,
767	self.xaxis_font, self.yaxis_font,
768	find_key(self.get_loc_label(), self.legendLoc),
769	self.xcolor, self.ycolor,
770	self.is_xtick, self.is_ytick)
771	self.graphApp.Bind(wx.EVT_CLOSE, self.on_graphApp_close)
772
773	def on_graphApp_close(self, e):
774	"""
775	Gets values from graph appearance dialog and sends them off
776	to modify the plot
777	"""
778	self.onGridOnOff(self.graphApp.get_togglegrid())
779	self.xaxis_label = self.graphApp.get_xlab()
780	self.yaxis_label = self.graphApp.get_ylab()
781	self.xaxis_unit = self.graphApp.get_xunit()
782	self.yaxis_unit = self.graphApp.get_yunit()
783	self.xaxis_font = self.graphApp.get_xfont()
784	self.yaxis_font = self.graphApp.get_yfont()
785	self.is_xtick = self.graphApp.get_xtick_check()
786	self.is_ytick = self.graphApp.get_ytick_check()
787	if self.is_xtick:
788	self.xaxis_tick = self.xaxis_font
789	if self.is_ytick:
790	self.yaxis_tick = self.yaxis_font
791
792	self.xaxis(self.xaxis_label, self.xaxis_unit,
793	self.graphApp.get_xfont(), self.graphApp.get_xcolor(),
794	self.xaxis_tick)
795	self.yaxis(self.yaxis_label, self.yaxis_unit,
796	self.graphApp.get_yfont(), self.graphApp.get_ycolor(),
797	self.yaxis_tick)
798
799	self.graphApp.Destroy()

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py @ a2573fc

Download in other formats: