Plotter.py @ e2e5f3d

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

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

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

SasView

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

Download in other formats: