Plotter.py @ acd0591d

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since acd0591d was 1f34e00, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 6 years ago
Don't show the plot if no data. Removed debug assert.
Property mode set to `100644`
File size: 25.9 KB

Line
1	from PyQt5 import QtCore
2	from PyQt5 import QtGui
3	from PyQt5 import QtWidgets
4
5	import functools
6	import copy
7	import matplotlib as mpl
8	import numpy as np
9	from matplotlib.font_manager import FontProperties
10
11	from sas.qtgui.Plotting.PlotterData import Data1D
12	from sas.qtgui.Plotting.PlotterBase import PlotterBase
13	from sas.qtgui.Plotting.AddText import AddText
14	from sas.qtgui.Plotting.SetGraphRange import SetGraphRange
15	from sas.qtgui.Plotting.LinearFit import LinearFit
16	from sas.qtgui.Plotting.PlotProperties import PlotProperties
17	from sas.qtgui.Plotting.ScaleProperties import ScaleProperties
18
19	import sas.qtgui.Utilities.GuiUtils as GuiUtils
20	import sas.qtgui.Plotting.PlotUtilities as PlotUtilities
21
22	class PlotterWidget(PlotterBase):
23	"""
24	1D Plot widget for use with a QDialog
25	"""
26	def __init__(self, parent=None, manager=None, quickplot=False):
27	super(PlotterWidget, self).__init__(parent, manager=manager, quickplot=quickplot)
28
29	self.parent = parent
30
31	# Dictionary of {plot_id:Data1d}
32	self.plot_dict = {}
33	# Dictionaty of {plot_id:line}
34
35	self.plot_lines = {}
36	# Window for text add
37	self.addText = AddText(self)
38
39	# Log-ness of the axes
40	self.xLogLabel = "log10(x)"
41	self.yLogLabel = "log10(y)"
42
43	# Data container for the linear fit
44	self.fit_result = Data1D(x=[], y=[], dy=None)
45	self.fit_result.symbol = 13
46	self.fit_result.name = "Fit"
47
48	@property
49	def data(self):
50	return self._data
51
52	@data.setter
53	def data(self, value):
54	""" data setter """
55	self._data = value
56	if value._xunit:
57	self.xLabel = "%s(%s)"%(value._xaxis, value._xunit)
58	else:
59	self.xLabel = "%s"%(value._xaxis)
60	if value._yunit:
61	self.yLabel = "%s(%s)"%(value._yaxis, value._yunit)
62	else:
63	self.yLabel = "%s"%(value._yaxis)
64
65	if value.scale == 'linear' or value.isSesans:
66	self.xscale = 'linear'
67	self.yscale = 'linear'
68	self.title(title=value.name)
69
70	def plot(self, data=None, color=None, marker=None, hide_error=False, transform=True):
71	"""
72	Add a new plot of self._data to the chart.
73	"""
74	# Data1D
75	if isinstance(data, Data1D):
76	self.data = data
77	if not self._data or data is None:
78	return
79
80	is_fit = (self.data.id=="fit")
81
82	if not is_fit:
83	# make sure we have some function to operate on
84	if self.data.xtransform is None:
85	self.data.xtransform = 'log10(x)'
86	if self.data.ytransform is None:
87	self.data.ytransform = 'log10(y)'
88	#Added condition to Dmax explorer from P(r) perspective
89	if self.data._xaxis == 'D_{max}':
90	self.xscale = 'linear'
91	# Transform data if required.
92	if transform and (self.data.xtransform is not None or self.data.ytransform is not None):
93	_, _, xscale, yscale = GuiUtils.xyTransform(self.data, self.data.xtransform, self.data.ytransform)
94	if xscale != 'log':
95	self.xscale = xscale
96	if yscale != 'log':
97	self.yscale = yscale
98
99	# Redefine the Scale properties dialog
100	self.properties = ScaleProperties(self,
101	init_scale_x=self.data.xtransform,
102	init_scale_y=self.data.ytransform)
103
104	# Shortcuts
105	ax = self.ax
106	x = self._data.view.x
107	y = self._data.view.y
108
109	# Marker symbol. Passed marker is one of matplotlib.markers characters
110	# Alternatively, picked up from Data1D as an int index of PlotUtilities.SHAPES dict
111	if marker is None:
112	marker = self.data.symbol
113	# Try name first
114	try:
115	marker = dict(PlotUtilities.SHAPES)[marker]
116	except KeyError:
117	marker = list(PlotUtilities.SHAPES.values())[marker]
118
119	assert marker is not None
120	# Plot name
121	if self.data.title:
122	self.title(title=self.data.title)
123	else:
124	self.title(title=self.data.name)
125
126	# Error marker toggle
127	if hide_error is None:
128	hide_error = self.data.hide_error
129
130	# Plot color
131	if color is None:
132	color = self.data.custom_color
133
134	color = PlotUtilities.getValidColor(color)
135	self.data.custom_color = color
136
137	markersize = self._data.markersize
138
139	# Include scaling (log vs. linear)
140	ax.set_xscale(self.xscale, nonposx='clip')
141	ax.set_yscale(self.yscale, nonposy='clip')
142
143	# define the ranges
144	self.setRange = SetGraphRange(parent=self,
145	x_range=self.ax.get_xlim(), y_range=self.ax.get_ylim())
146
147	# Draw non-standard markers
148	l_width = markersize * 0.4
149	if marker == '-' or marker == '--':
150	line = self.ax.plot(x, y, color=color, lw=l_width, marker='',
151	linestyle=marker, label=self._title, zorder=10)[0]
152
153	elif marker == 'vline':
154	y_min = min(y)*9.0/10.0 if min(y) < 0 else 0.0
155	line = self.ax.vlines(x=x, ymin=y_min, ymax=y, color=color,
156	linestyle='-', label=self._title, lw=l_width, zorder=1)
157
158	elif marker == 'step':
159	line = self.ax.step(x, y, color=color, marker='', linestyle='-',
160	label=self._title, lw=l_width, zorder=1)[0]
161
162	else:
163	# plot data with/without errorbars
164	if hide_error:
165	line = ax.plot(x, y, marker=marker, color=color, markersize=markersize,
166	linestyle='', label=self._title, picker=True)
167	else:
168	dy = self._data.view.dy
169	# Convert tuple (lo,hi) to array [(x-lo),(hi-x)]
170	if dy is not None and type(dy) == type(()):
171	dy = np.vstack((y - dy[0], dy[1] - y)).transpose()
172
173	line = ax.errorbar(x, y,
174	yerr=dy,
175	xerr=None,
176	capsize=2, linestyle='',
177	barsabove=False,
178	color=color,
179	marker=marker,
180	markersize=markersize,
181	lolims=False, uplims=False,
182	xlolims=False, xuplims=False,
183	label=self._title,
184	zorder=1,
185	picker=True)
186
187	# Update the list of data sets (plots) in chart
188	self.plot_dict[self._data.name] = self.data
189
190	self.plot_lines[self._data.name] = line
191
192	# Now add the legend with some customizations.
193
194	if self.showLegend:
195	self.legend = ax.legend(loc='upper right', shadow=True)
196	if self.legend:
197	self.legend.set_picker(True)
198
199	# Current labels for axes
200	if self.y_label and not is_fit:
201	ax.set_ylabel(self.y_label)
202	if self.x_label and not is_fit:
203	ax.set_xlabel(self.x_label)
204
205	# refresh canvas
206	self.canvas.draw()
207
208	def createContextMenu(self):
209	"""
210	Define common context menu and associated actions for the MPL widget
211	"""
212	self.defaultContextMenu()
213
214	# Separate plots
215	self.addPlotsToContextMenu()
216
217	# Additional menu items
218	self.contextMenu.addSeparator()
219	self.actionAddText = self.contextMenu.addAction("Add Text")
220	self.actionRemoveText = self.contextMenu.addAction("Remove Text")
221	self.contextMenu.addSeparator()
222	self.actionChangeScale = self.contextMenu.addAction("Change Scale")
223	self.contextMenu.addSeparator()
224	self.actionSetGraphRange = self.contextMenu.addAction("Set Graph Range")
225	self.actionResetGraphRange =\
226	self.contextMenu.addAction("Reset Graph Range")
227	# Add the title change for dialogs
228	self.contextMenu.addSeparator()
229	self.actionWindowTitle = self.contextMenu.addAction("Window Title")
230
231	# Define the callbacks
232	self.actionAddText.triggered.connect(self.onAddText)
233	self.actionRemoveText.triggered.connect(self.onRemoveText)
234	self.actionChangeScale.triggered.connect(self.onScaleChange)
235	self.actionSetGraphRange.triggered.connect(self.onSetGraphRange)
236	self.actionResetGraphRange.triggered.connect(self.onResetGraphRange)
237	self.actionWindowTitle.triggered.connect(self.onWindowsTitle)
238
239	def addPlotsToContextMenu(self):
240	"""
241	Adds operations on all plotted sets of data to the context menu
242	"""
243	for id in list(self.plot_dict.keys()):
244	plot = self.plot_dict[id]
245
246	name = plot.name if plot.name else plot.title
247	plot_menu = self.contextMenu.addMenu('&%s' % name)
248
249	self.actionDataInfo = plot_menu.addAction("&DataInfo")
250	self.actionDataInfo.triggered.connect(
251	functools.partial(self.onDataInfo, plot))
252
253	self.actionSavePointsAsFile = plot_menu.addAction("&Save Points as a File")
254	self.actionSavePointsAsFile.triggered.connect(
255	functools.partial(self.onSavePoints, plot))
256	plot_menu.addSeparator()
257
258	if plot.id != 'fit':
259	self.actionLinearFit = plot_menu.addAction('&Linear Fit')
260	self.actionLinearFit.triggered.connect(
261	functools.partial(self.onLinearFit, id))
262	plot_menu.addSeparator()
263
264	self.actionRemovePlot = plot_menu.addAction("Remove")
265	self.actionRemovePlot.triggered.connect(
266	functools.partial(self.onRemovePlot, id))
267
268	if not plot.is_data:
269	self.actionFreeze = plot_menu.addAction('&Freeze')
270	self.actionFreeze.triggered.connect(
271	functools.partial(self.onFreeze, id))
272	plot_menu.addSeparator()
273
274	if plot.is_data:
275	self.actionHideError = plot_menu.addAction("Hide Error Bar")
276	if plot.dy is not None and plot.dy != []:
277	if plot.hide_error:
278	self.actionHideError.setText('Show Error Bar')
279	else:
280	self.actionHideError.setEnabled(False)
281	self.actionHideError.triggered.connect(
282	functools.partial(self.onToggleHideError, id))
283	plot_menu.addSeparator()
284
285	self.actionModifyPlot = plot_menu.addAction('&Modify Plot Property')
286	self.actionModifyPlot.triggered.connect(
287	functools.partial(self.onModifyPlot, id))
288
289	def createContextMenuQuick(self):
290	"""
291	Define context menu and associated actions for the quickplot MPL widget
292	"""
293	# Default actions
294	self.defaultContextMenu()
295
296	# Additional actions
297	self.actionToggleGrid = self.contextMenu.addAction("Toggle Grid On/Off")
298	self.contextMenu.addSeparator()
299	self.actionChangeScale = self.contextMenu.addAction("Change Scale")
300
301	# Define the callbacks
302	self.actionToggleGrid.triggered.connect(self.onGridToggle)
303	self.actionChangeScale.triggered.connect(self.onScaleChange)
304
305	def onScaleChange(self):
306	"""
307	Show a dialog allowing axes rescaling
308	"""
309	if self.properties.exec_() == QtWidgets.QDialog.Accepted:
310	self.xLogLabel, self.yLogLabel = self.properties.getValues()
311	self.data.xtransform = self.xLogLabel
312	self.data.ytransform = self.yLogLabel
313	self.xyTransform(self.xLogLabel, self.yLogLabel)
314
315	def onAddText(self):
316	"""
317	Show a dialog allowing adding custom text to the chart
318	"""
319	if self.addText.exec_() != QtWidgets.QDialog.Accepted:
320	return
321
322	# Retrieve the new text, its font and color
323	extra_text = self.addText.text()
324	extra_font = self.addText.font()
325	extra_color = self.addText.color()
326
327	# Place the text on the screen at the click location
328	pos_x = self.x_click
329	pos_y = self.y_click
330
331	# Map QFont onto MPL font
332	mpl_font = FontProperties()
333	mpl_font.set_size(int(extra_font.pointSize()))
334	mpl_font.set_family(str(extra_font.family()))
335	mpl_font.set_weight(int(extra_font.weight()))
336	# MPL style names
337	styles = ['normal', 'italic', 'oblique']
338	# QFont::Style maps directly onto the above
339	try:
340	mpl_font.set_style(styles[extra_font.style()])
341	except:
342	pass
343
344	if len(extra_text) > 0:
345	new_text = self.ax.text(pos_x,
346	pos_y,
347	extra_text,
348	color=extra_color,
349	fontproperties=mpl_font)
350
351	# Update the list of annotations
352	self.textList.append(new_text)
353	self.canvas.draw()
354
355	def onRemoveText(self):
356	"""
357	Remove the most recently added text
358	"""
359	num_text = len(self.textList)
360	if num_text < 1:
361	return
362	txt = self.textList[num_text - 1]
363	text_remove = txt.get_text()
364	try:
365	txt.remove()
366	except ValueError:
367	# Text got already deleted somehow
368	pass
369	self.textList.remove(txt)
370
371	self.canvas.draw_idle()
372
373	def onSetGraphRange(self):
374	"""
375	Show a dialog allowing setting the chart ranges
376	"""
377	# min and max of data
378	if self.setRange.exec_() == QtWidgets.QDialog.Accepted:
379	x_range = self.setRange.xrange()
380	y_range = self.setRange.yrange()
381	if x_range is not None and y_range is not None:
382	self.ax.set_xlim(x_range)
383	self.ax.set_ylim(y_range)
384	self.canvas.draw_idle()
385
386	def onResetGraphRange(self):
387	"""
388	Resets the chart X and Y ranges to their original values
389	"""
390	x_range = (self.data.x.min(), self.data.x.max())
391	y_range = (self.data.y.min(), self.data.y.max())
392	if x_range is not None and y_range is not None:
393	self.ax.set_xlim(x_range)
394	self.ax.set_ylim(y_range)
395	self.canvas.draw_idle()
396
397	def onLinearFit(self, id):
398	"""
399	Creates and displays a simple linear fit for the selected plot
400	"""
401	selected_plot = self.plot_dict[id]
402
403	maxrange = (min(selected_plot.x), max(selected_plot.x))
404	fitrange = self.ax.get_xlim()
405
406	fit_dialog = LinearFit(parent=self,
407	data=selected_plot,
408	max_range=maxrange,
409	fit_range=fitrange,
410	xlabel=self.xLogLabel,
411	ylabel=self.yLogLabel)
412	fit_dialog.updatePlot.connect(self.onFitDisplay)
413	if fit_dialog.exec_() == QtWidgets.QDialog.Accepted:
414	return
415
416	def replacePlot(self, id, new_plot):
417	"""
418	Remove plot 'id' and add 'new_plot' to the chart.
419	This effectlvely refreshes the chart with changes to one of its plots
420	"""
421	self.removePlot(id)
422	self.plot(data=new_plot)
423
424	def onRemovePlot(self, id):
425	"""
426	Responds to the plot delete action
427	"""
428	self.removePlot(id)
429
430	if len(self.plot_dict) == 0:
431	# last plot: graph is empty must be the panel must be destroyed
432	self.parent.close()
433
434	def removePlot(self, id):
435	"""
436	Deletes the selected plot from the chart
437	"""
438	if id not in list(self.plot_dict.keys()):
439	return
440
441	selected_plot = self.plot_dict[id]
442
443	plot_dict = copy.deepcopy(self.plot_dict)
444
445	# Labels might have been changed
446	xl = self.ax.xaxis.label.get_text()
447	yl = self.ax.yaxis.label.get_text()
448
449	self.plot_dict = {}
450
451	mpl.pyplot.cla()
452	self.ax.cla()
453
454	for ids in plot_dict:
455	if ids != id:
456	self.plot(data=plot_dict[ids], hide_error=plot_dict[ids].hide_error)
457
458	# Reset the labels
459	self.ax.set_xlabel(xl)
460	self.ax.set_ylabel(yl)
461	self.canvas.draw()
462
463	def onFreeze(self, id):
464	"""
465	Freezes the selected plot to a separate chart
466	"""
467	plot = self.plot_dict[id]
468	self.manager.add_data(data_list=[plot])
469
470	def onModifyPlot(self, id):
471	"""
472	Allows for MPL modifications to the selected plot
473	"""
474	selected_plot = self.plot_dict[id]
475	selected_line = self.plot_lines[id]
476	# Old style color - single integer for enum color
477	# New style color - #hhhhhh
478	color = selected_plot.custom_color
479	# marker symbol and size
480	marker = selected_plot.symbol
481	marker_size = selected_plot.markersize
482	# plot name
483	legend = selected_plot.title
484
485	plotPropertiesWidget = PlotProperties(self,
486	color=color,
487	marker=marker,
488	marker_size=marker_size,
489	legend=legend)
490	if plotPropertiesWidget.exec_() == QtWidgets.QDialog.Accepted:
491	# Update Data1d
492	selected_plot.markersize = plotPropertiesWidget.markersize()
493	selected_plot.custom_color = plotPropertiesWidget.color()
494	selected_plot.symbol = plotPropertiesWidget.marker()
495	selected_plot.title = plotPropertiesWidget.legend()
496
497	# Redraw the plot
498	self.replacePlot(id, selected_plot)
499
500	def onToggleHideError(self, id):
501	"""
502	Toggles hide error/show error menu item
503	"""
504	selected_plot = self.plot_dict[id]
505	current = selected_plot.hide_error
506
507	# Flip the flag
508	selected_plot.hide_error = not current
509
510	plot_dict = copy.deepcopy(self.plot_dict)
511	self.plot_dict = {}
512
513	# Clean the canvas
514	mpl.pyplot.cla()
515	self.ax.cla()
516
517	# Recreate the plots but reverse the error flag for the current
518	for ids in plot_dict:
519	if ids == id:
520	self.plot(data=plot_dict[ids], hide_error=(not current))
521	else:
522	self.plot(data=plot_dict[ids], hide_error=plot_dict[ids].hide_error)
523
524	def xyTransform(self, xLabel="", yLabel=""):
525	"""
526	Transforms x and y in View and set the scale
527	"""
528	# Transform all the plots on the chart
529	for id in list(self.plot_dict.keys()):
530	current_plot = self.plot_dict[id]
531	if current_plot.id == "fit":
532	self.removePlot(id)
533	continue
534
535	new_xlabel, new_ylabel, xscale, yscale =\
536	GuiUtils.xyTransform(current_plot, xLabel, yLabel)
537	self.xscale = xscale
538	self.yscale = yscale
539
540	# Plot the updated chart
541	self.removePlot(id)
542
543	# This assignment will wrap the label in Latex "$"
544	self.xLabel = new_xlabel
545	self.yLabel = new_ylabel
546
547	self.plot(data=current_plot, transform=False)
548
549	pass # debug hook
550
551	def onFitDisplay(self, fit_data):
552	"""
553	Add a linear fitting line to the chart
554	"""
555	# Create new data structure with fitting result
556	tempx = fit_data[0]
557	tempy = fit_data[1]
558	self.fit_result.x = []
559	self.fit_result.y = []
560	self.fit_result.x = tempx
561	self.fit_result.y = tempy
562	self.fit_result.dx = None
563	self.fit_result.dy = None
564
565	#Remove another Fit, if exists
566	self.removePlot("Fit")
567
568	self.fit_result.reset_view()
569	#self.offset_graph()
570
571	# Set plot properties
572	self.fit_result.id = 'fit'
573	self.fit_result.title = 'Fit'
574	self.fit_result.name = 'Fit'
575
576	# Plot the line
577	self.plot(data=self.fit_result, marker='-', hide_error=True)
578
579	def onMplMouseDown(self, event):
580	"""
581	Left button down and ready to drag
582	"""
583	# Check that the LEFT button was pressed
584	if event.button != 1:
585	return
586
587	self.leftdown = True
588	for text in self.textList:
589	if text.contains(event)[0]: # If user has clicked on text
590	self.selectedText = text
591	return
592	if event.inaxes is None:
593	return
594	try:
595	self.x_click = float(event.xdata) # / size_x
596	self.y_click = float(event.ydata) # / size_y
597	except:
598	self.position = None
599
600	def onMplMouseUp(self, event):
601	"""
602	Set the data coordinates of the click
603	"""
604	self.x_click = event.xdata
605	self.y_click = event.ydata
606
607	# Check that the LEFT button was released
608	if event.button == 1:
609	self.leftdown = False
610	self.selectedText = None
611
612	#release the legend
613	if self.gotLegend == 1:
614	self.gotLegend = 0
615
616	def onMplMouseMotion(self, event):
617	"""
618	Check if the left button is press and the mouse in moving.
619	Compute delta for x and y coordinates and then perform the drag
620	"""
621	if self.gotLegend == 1 and self.leftdown:
622	self.onLegendMotion(event)
623	return
624
625	#if self.leftdown and self.selectedText is not None:
626	if not self.leftdown or self.selectedText is None:
627	return
628	# User has clicked on text and is dragging
629	if event.inaxes is None:
630	# User has dragged outside of axes
631	self.selectedText = None
632	else:
633	# Only move text if mouse is within axes
634	self.selectedText.set_position((event.xdata, event.ydata))
635	self.canvas.draw_idle()
636	return
637
638	def onMplPick(self, event):
639	"""
640	On pick legend
641	"""
642	legend = self.legend
643	if event.artist != legend:
644	return
645	# Get the box of the legend.
646	bbox = self.legend.get_window_extent()
647	# Get mouse coordinates at time of pick.
648	self.mouse_x = event.mouseevent.x
649	self.mouse_y = event.mouseevent.y
650	# Get legend coordinates at time of pick.
651	self.legend_x = bbox.xmin
652	self.legend_y = bbox.ymin
653	# Indicate we picked up the legend.
654	self.gotLegend = 1
655
656	#self.legend.legendPatch.set_alpha(0.5)
657
658	def onLegendMotion(self, event):
659	"""
660	On legend in motion
661	"""
662	ax = event.inaxes
663	if ax is None:
664	return
665	# Event occurred inside a plotting area
666	lo_x, hi_x = ax.get_xlim()
667	lo_y, hi_y = ax.get_ylim()
668	# How much the mouse moved.
669	x = mouse_diff_x = self.mouse_x - event.x
670	y = mouse_diff_y = self.mouse_y - event.y
671	# Put back inside
672	if x < lo_x:
673	x = lo_x
674	if x > hi_x:
675	x = hi_x
676	if y < lo_y:
677	y = lo_y
678	if y > hi_y:
679	y = hi_y
680	# Move the legend from its previous location by that same amount
681	loc_in_canvas = self.legend_x - mouse_diff_x, \
682	self.legend_y - mouse_diff_y
683	# Transform into legend coordinate system
684	trans_axes = self.legend.parent.transAxes.inverted()
685	loc_in_norm_axes = trans_axes.transform_point(loc_in_canvas)
686	self.legend_pos_loc = tuple(loc_in_norm_axes)
687	self.legend._loc = self.legend_pos_loc
688	# self.canvas.draw()
689	self.canvas.draw_idle()
690
691	def onMplWheel(self, event):
692	"""
693	Process mouse wheel as zoom events
694	"""
695	ax = event.inaxes
696	step = event.step
697
698	if ax is not None:
699	# Event occurred inside a plotting area
700	lo, hi = ax.get_xlim()
701	lo, hi = PlotUtilities.rescale(lo, hi, step,
702	pt=event.xdata, scale=ax.get_xscale())
703	if not self.xscale == 'log' or lo > 0:
704	self._scale_xlo = lo
705	self._scale_xhi = hi
706	ax.set_xlim((lo, hi))
707
708	lo, hi = ax.get_ylim()
709	lo, hi = PlotUtilities.rescale(lo, hi, step, pt=event.ydata,
710	scale=ax.get_yscale())
711	if not self.yscale == 'log' or lo > 0:
712	self._scale_ylo = lo
713	self._scale_yhi = hi
714	ax.set_ylim((lo, hi))
715	else:
716	# Check if zoom happens in the axes
717	xdata, ydata = None, None
718	x, y = event.x, event.y
719
720	for ax in self.axes:
721	insidex, _ = ax.xaxis.contains(event)
722	if insidex:
723	xdata, _ = ax.transAxes.inverted().transform_point((x, y))
724	insidey, _ = ax.yaxis.contains(event)
725	if insidey:
726	_, ydata = ax.transAxes.inverted().transform_point((x, y))
727	if xdata is not None:
728	lo, hi = ax.get_xlim()
729	lo, hi = PlotUtilities.rescale(lo, hi, step,
730	bal=xdata, scale=ax.get_xscale())
731	if not self.xscale == 'log' or lo > 0:
732	self._scale_xlo = lo
733	self._scale_xhi = hi
734	ax.set_xlim((lo, hi))
735	if ydata is not None:
736	lo, hi = ax.get_ylim()
737	lo, hi = PlotUtilities.rescale(lo, hi, step, bal=ydata,
738	scale=ax.get_yscale())
739	if not self.yscale == 'log' or lo > 0:
740	self._scale_ylo = lo
741	self._scale_yhi = hi
742	ax.set_ylim((lo, hi))
743	self.canvas.draw_idle()
744
745
746	class Plotter(QtWidgets.QDialog, PlotterWidget):
747	def __init__(self, parent=None, quickplot=False):
748
749	QtWidgets.QDialog.__init__(self)
750	PlotterWidget.__init__(self, parent=self, manager=parent, quickplot=quickplot)
751	icon = QtGui.QIcon()
752	icon.addPixmap(QtGui.QPixmap(":/res/ball.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
753	self.setWindowIcon(icon)
754
755

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

SasView

source: sasview/src/sas/qtgui/Plotting/Plotter.py @ acd0591d

Download in other formats: