Context Navigation

source: trunk/python/asapplotter.py @ 2977

Visit:

Last change on this file since 2977 was 2977, checked in by Kana Sugimoto, 10 years ago

New Development: No

JIRA Issue: Yes (CAS-6564)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): asapplotter, sdplot

Description: Fixed a bug in azel plot which causes an error by too many minor ticks for some data.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 78.5 KB

Line
1	from asap.parameters import rcParams
2	from asap.selector import selector
3	from asap.scantable import scantable
4	from asap.logging import asaplog, asaplog_post_dec
5	import matplotlib.axes
6	from matplotlib.font_manager import FontProperties
7	from matplotlib.text import Text
8	from matplotlib import _pylab_helpers
9
10	import re
11
12	def new_asaplot(visible=None,**kwargs):
13	"""
14	Returns a new asaplot instance based on the backend settings.
15	"""
16	if visible == None:
17	visible = rcParams['plotter.gui']
18
19	backend=matplotlib.get_backend()
20	if not visible:
21	from asap.asaplot import asaplot
22	elif backend == 'TkAgg':
23	from asap.asaplotgui import asaplotgui as asaplot
24	elif backend == 'Qt4Agg':
25	from asap.asaplotgui_qt4 import asaplotgui as asaplot
26	elif backend == 'GTkAgg':
27	from asap.asaplotgui_gtk import asaplotgui as asaplot
28	else:
29	from asap.asaplot import asaplot
30	return asaplot(**kwargs)
31
32	class asapplotter:
33	"""
34	The ASAP plotter.
35	By default the plotter is set up to plot polarisations
36	'colour stacked' and scantables across panels.
37
38	.. note::
39
40	Currenly it only plots 'spectra' not Tsys or
41	other variables.
42
43	"""
44	def __init__(self, visible=None , **kwargs):
45	self._visible = rcParams['plotter.gui']
46	if visible is not None:
47	self._visible = visible
48	self._plotter = None
49	self._inikwg = kwargs
50
51	### plot settings
52	self._colormap = None
53	self._linestyles = None
54	self._fp = FontProperties()
55	self._rows = None
56	self._cols = None
57	self._minmaxx = None
58	self._minmaxy = None
59	self._margins = self.set_margin(refresh=False)
60	self._legendloc = None
61	### scantable plot settings
62	self._plotmode = "spectra"
63	self._panelling = None
64	self._stacking = None
65	self.set_panelling()
66	self.set_stacking()
67	self._hist = rcParams['plotter.histogram']
68	### scantable dependent settings
69	self._data = None
70	self._abcunit = None
71	self._headtext = {'string': None, 'textobj': None}
72	self._selection = selector()
73	self._usermask = []
74	self._maskselection = None
75	self._offset = None
76	self._lmap = None
77	self._title = None
78	self._ordinate = None
79	self._abcissa = None
80	### cursors for page iteration
81	self._startrow = 0
82	self._ipanel = -1
83	self._panelrows = []
84
85	def _translate(self, instr):
86	keys = "s b i p t r".split()
87	if isinstance(instr, str):
88	for key in keys:
89	if instr.lower().startswith(key):
90	return key
91	return None
92
93	@asaplog_post_dec
94	def _reload_plotter(self):
95	if self._plotter is not None:
96	#if not self._plotter.is_dead:
97	# # clear lines and axes
98	# try:
99	# self._plotter.clear()
100	# except: # Can't remove when already killed.
101	# pass
102	if self.casabar_exists():
103	del self._plotter.figmgr.casabar
104	self._plotter.quit()
105	del self._plotter
106	asaplog.push('Loading new plotter')
107	self._plotter = new_asaplot(self._visible,**self._inikwg)
108	self._plotter.figmgr.casabar=self._new_custombar()
109	# just to make sure they're set
110	self._plotter.palette(color=0,colormap=self._colormap,
111	linestyle=0,linestyles=self._linestyles)
112	self._plotter.legend(self._legendloc)
113
114	### TODO: it's probably better to define following two methods in
115	### backend dependent class.
116	def _new_custombar(self):
117	backend=matplotlib.get_backend()
118	if not self._visible:
119	return None
120	elif backend == "TkAgg":
121	from asap.customgui_tkagg import CustomToolbarTkAgg
122	return CustomToolbarTkAgg(self)
123	elif backend == "Qt4Agg":
124	from asap.customgui_qt4agg import CustomToolbarQT4Agg
125	return CustomToolbarQT4Agg(self)
126	return None
127
128	def casabar_exists(self):
129	if not hasattr(self._plotter.figmgr,'casabar'):
130	return False
131	elif self._plotter.figmgr.casabar:
132	return True
133	return False
134	### end of TODO
135
136	def _assert_plotter(self,action="status",errmsg=None):
137	"""
138	Check plot window status. Returns True if plot window is alive.
139	Parameters
140	action: An action to take if the plotter window is not alive.
141	['status'\|'reload'\|'halt']
142	The action 'status' simply returns False if asaplot
143	is not alive. When action='reload', plot window is
144	reloaded and the method returns True. Finally, an
145	error is raised when action='halt'.
146	errmsg: An error (warning) message to send to the logger,
147	when plot window is not alive.
148	"""
149	isAlive = (self._plotter is not None) and self._plotter._alive()
150	# More tests
151	#if isAlive:
152	# if self._plotter.figmgr:
153	# figmgr = self._plotter.figmgr
154	# figid = figmgr.num
155	# # Make sure figid=0 is what asapplotter expects.
156	# # It might be already destroied/overridden by matplotlib
157	# # commands or other plotting methods using asaplot.
158	# isAlive = _pylab_helpers.Gcf.has_fignum(figid) and \
159	# (figmgr == \
160	# _pylab_helpers.Gcf.get_fig_manager(figid))
161	# else:
162	# isAlive = False
163
164	if isAlive:
165	return True
166	# Plotter is not alive.
167	haltmsg = "Plotter window has not yet been loaded or is closed."
168	if type(errmsg)==str and len(errmsg) > 0:
169	haltmsg = errmsg
170
171	if action.upper().startswith("R"):
172	# reload plotter
173	self._reload_plotter()
174	return True
175	elif action.upper().startswith("H"):
176	# halt
177	asaplog.push(haltmsg)
178	asaplog.post("ERROR")
179	raise RuntimeError(haltmsg)
180	else:
181	if errmsg:
182	asaplog.push(errmsg)
183	asaplog.post("WARN")
184	return False
185
186
187	def gca(self):
188	errmsg = "No axis to retun. Need to plot first."
189	if not self._assert_plotter(action="status",errmsg=errmsg):
190	return None
191	return self._plotter.figure.gca()
192
193	def refresh(self):
194	"""Do a soft refresh"""
195	errmsg = "No figure to re-plot. Need to plot first."
196	self._assert_plotter(action="halt",errmsg=errmsg)
197
198	self._plotter.figure.show()
199
200	def save(self, filename=None, orientation=None, dpi=None):
201	"""
202	Save the plot to a file. The known formats are 'png', 'ps', 'eps'.
203	Parameters:
204	filename: The name of the output file. This is optional
205	and autodetects the image format from the file
206	suffix. If non filename is specified a file
207	called 'yyyymmdd_hhmmss.png' is created in the
208	current directory.
209	orientation: optional parameter for postscript only (not eps).
210	'landscape', 'portrait' or None (default) are valid.
211	If None is choosen for 'ps' output, the plot is
212	automatically oriented to fill the page.
213	dpi: The dpi of the output non-ps plot
214	"""
215	errmsg = "Cannot save figure. Need to plot first."
216	self._assert_plotter(action="halt",errmsg=errmsg)
217
218	self._plotter.save(filename,orientation,dpi)
219	return
220
221	def create_mask(self, nwin=1, panel=0, color=None):
222	"""
223	Interactively define a mask. It retruns a mask that is equivalent to
224	the one created manually with scantable.create_mask.
225	Parameters:
226	nwin: The number of mask windows to create interactively
227	default is 1.
228	panel: Which panel to use for mask selection. This is useful
229	if different IFs are spread over panels (default 0)
230	"""
231	## this method relies on already plotted figure
232	if not self._assert_plotter(action="status") or (self._data is None):
233	msg = "Cannot create mask interactively on plot. Can only create mask after plotting."
234	asaplog.push( msg )
235	asaplog.post( "ERROR" )
236	return []
237	outmask = []
238	self._plotter.subplot(panel)
239	xmin, xmax = self._plotter.axes.get_xlim()
240	marg = 0.05*(xmax-xmin)
241	self._plotter.axes.set_xlim(xmin-marg, xmax+marg)
242	self.refresh()
243
244	def cleanup(lines=False, texts=False, refresh=False):
245	if lines:
246	del self._plotter.axes.lines[-1]
247	if texts:
248	del self._plotter.axes.texts[-1]
249	if refresh:
250	self.refresh()
251
252	for w in xrange(nwin):
253	wpos = []
254	self.text(0.05,1.0, "Add start boundary",
255	coords="relative", fontsize=10)
256	point = self._plotter.get_point()
257	cleanup(texts=True)
258	if point is None:
259	continue
260	wpos.append(point[0])
261	self.axvline(wpos[0], color=color)
262	self.text(0.05,1.0, "Add end boundary", coords="relative", fontsize=10)
263	point = self._plotter.get_point()
264	cleanup(texts=True, lines=True)
265	if point is None:
266	self.refresh()
267	continue
268	wpos.append(point[0])
269	self.axvspan(wpos[0], wpos[1], alpha=0.1,
270	edgecolor=color, facecolor=color)
271	ymin, ymax = self._plotter.axes.get_ylim()
272	outmask.append(wpos)
273
274	self._plotter.axes.set_xlim(xmin, xmax)
275	self.refresh()
276	if len(outmask) > 0:
277	return self._data.create_mask(*outmask)
278	return []
279
280
281	### Forwards to methods in matplotlib axes ###
282	def text(self, args, *kwargs):
283	self._assert_plotter(action="reload")
284	if kwargs.has_key("interactive"):
285	if kwargs.pop("interactive"):
286	pos = self._plotter.get_point()
287	args = tuple(pos)+args
288	self._axes_callback("text", args, *kwargs)
289
290	text.__doc__ = matplotlib.axes.Axes.text.__doc__
291
292	def arrow(self, args, *kwargs):
293	self._assert_plotter(action="reload")
294	if kwargs.has_key("interactive"):
295	if kwargs.pop("interactive"):
296	pos = self._plotter.get_region()
297	dpos = (pos[0][0], pos[0][1],
298	pos[1][0]-pos[0][0],
299	pos[1][1] - pos[0][1])
300	args = dpos + args
301	self._axes_callback("arrow", args, *kwargs)
302
303	arrow.__doc__ = matplotlib.axes.Axes.arrow.__doc__
304
305	def annotate(self, text, xy=None, xytext=None, **kwargs):
306	self._assert_plotter(action="reload")
307	if kwargs.has_key("interactive"):
308	if kwargs.pop("interactive"):
309	xy = self._plotter.get_point()
310	xytext = self._plotter.get_point()
311	if not kwargs.has_key("arrowprops"):
312	kwargs["arrowprops"] = dict(arrowstyle="->")
313	self._axes_callback("annotate", text, xy, xytext, **kwargs)
314
315	annotate.__doc__ = matplotlib.axes.Axes.annotate.__doc__
316
317	def axvline(self, args, *kwargs):
318	self._assert_plotter(action="reload")
319	if kwargs.has_key("interactive"):
320	if kwargs.pop("interactive"):
321	pos = self._plotter.get_point()
322	args = (pos[0],)+args
323	self._axes_callback("axvline", args, *kwargs)
324
325	axvline.__doc__ = matplotlib.axes.Axes.axvline.__doc__
326
327	def axhline(self, args, *kwargs):
328	self._assert_plotter(action="reload")
329	if kwargs.has_key("interactive"):
330	if kwargs.pop("interactive"):
331	pos = self._plotter.get_point()
332	args = (pos[1],)+args
333	self._axes_callback("axhline", args, *kwargs)
334
335	axhline.__doc__ = matplotlib.axes.Axes.axhline.__doc__
336
337	def axvspan(self, args, *kwargs):
338	self._assert_plotter(action="reload")
339	if kwargs.has_key("interactive"):
340	if kwargs.pop("interactive"):
341	pos = self._plotter.get_region()
342	dpos = (pos[0][0], pos[1][0])
343	args = dpos + args
344	self._axes_callback("axvspan", args, *kwargs)
345	# hack to preventy mpl from redrawing the patch
346	# it seem to convert the patch into lines on every draw.
347	# This doesn't happen in a test script???
348	#del self._plotter.axes.patches[-1]
349
350	axvspan.__doc__ = matplotlib.axes.Axes.axvspan.__doc__
351
352	def axhspan(self, args, *kwargs):
353	self._assert_plotter(action="reload")
354	if kwargs.has_key("interactive"):
355	if kwargs.pop("interactive"):
356	pos = self._plotter.get_region()
357	dpos = (pos[0][1], pos[1][1])
358	args = dpos + args
359	self._axes_callback("axhspan", args, *kwargs)
360	# hack to preventy mpl from redrawing the patch
361	# it seem to convert the patch into lines on every draw.
362	# This doesn't happen in a test script???
363	#del self._plotter.axes.patches[-1]
364
365	axhspan.__doc__ = matplotlib.axes.Axes.axhspan.__doc__
366
367	def _axes_callback(self, axesfunc, args, *kwargs):
368	self._assert_plotter(action="reload")
369	panel = 0
370	if kwargs.has_key("panel"):
371	panel = kwargs.pop("panel")
372	coords = None
373	if kwargs.has_key("coords"):
374	coords = kwargs.pop("coords")
375	if coords.lower() == 'world':
376	kwargs["transform"] = self._plotter.axes.transData
377	elif coords.lower() == 'relative':
378	kwargs["transform"] = self._plotter.axes.transAxes
379	self._plotter.subplot(panel)
380	self._plotter.axes.set_autoscale_on(False)
381	getattr(self._plotter.axes, axesfunc)(args, *kwargs)
382	self._plotter.show(False)
383	self._plotter.axes.set_autoscale_on(True)
384	# end matplotlib.axes fowarding functions
385
386
387	### Forwards to matplotlib.Figure.text ###
388	def figtext(self, args, *kwargs):
389	"""
390	Add text to figure at location x,y (relative 0-1 coords).
391	This method forwards args and *kwargs to a Matplotlib method,
392	matplotlib.Figure.text.
393	See the method help for detailed information.
394	"""
395	self._assert_plotter(action="reload")
396	self._plotter.text(args, *kwargs)
397	# end matplotlib.Figure.text forwarding function
398
399
400	### Set Plot parameters ###
401	@asaplog_post_dec
402	def set_data(self, scan, refresh=True):
403	"""
404	Set a scantable to plot.
405	Parameters:
406	scan: a scantable
407	refresh: True (default) or False. If True, the plot is
408	replotted based on the new parameter setting(s).
409	Otherwise,the parameter(s) are set without replotting.
410	Note:
411	The user specified masks and data selections will be reset
412	if a new scantable is set. This method should be called before
413	setting data selections (set_selection) and/or masks (set_mask).
414	"""
415	from asap import scantable
416	if isinstance(scan, scantable):
417	if (self._data is not None) and (scan != self._data):
418	del self._data
419	msg = "A new scantable is set to the plotter. "\
420	"The masks, data selections, and labels are reset."
421	asaplog.push(msg)
422	self._data = scan
423	# reset
424	self._reset()
425	else:
426	msg = "Input is not a scantable"
427	raise TypeError(msg)
428
429	# ranges become invalid when unit changes
430	if self._abcunit and self._abcunit != self._data.get_unit():
431	self._minmaxx = None
432	self._minmaxy = None
433	self._abcunit = self._data.get_unit()
434	if refresh: self.plot()
435
436	@asaplog_post_dec
437	def set_mode(self, stacking=None, panelling=None, refresh=True):
438	"""
439	Set the plots look and feel, i.e. what you want to see on the plot.
440	Parameters:
441	stacking: tell the plotter which variable to plot
442	as line colour overlays (default 'pol')
443	panelling: tell the plotter which variable to plot
444	across multiple panels (default 'scan'
445	refresh: True (default) or False. If True, the plot is
446	replotted based on the new parameter setting(s).
447	Otherwise,the parameter(s) are set without replotting.
448	Note:
449	Valid modes are:
450	'beam' 'Beam' 'b': Beams
451	'if' 'IF' 'i': IFs
452	'pol' 'Pol' 'p': Polarisations
453	'scan' 'Scan' 's': Scans
454	'time' 'Time' 't': Times
455	'row' 'Row' 'r': Rows
456	When either 'stacking' or 'panelling' is set to 'row',
457	the other parameter setting is ignored.
458	"""
459	msg = "Invalid mode"
460	if not self.set_panelling(panelling) or \
461	not self.set_stacking(stacking):
462	raise TypeError(msg)
463	#if self._panelling == 'r':
464	# self._stacking = '_r'
465	#if self._stacking == 'r':
466	# self._panelling = '_r'
467	if refresh and self._data: self.plot(self._data)
468	return
469
470	def set_stacking(self, what=None):
471	"""Set the 'stacking' mode i.e. which type of spectra should be
472	overlayed.
473	"""
474	mode = what
475	if mode is None:
476	mode = rcParams['plotter.stacking']
477	md = self._translate(mode)
478	if md:
479	self._stacking = md
480	self._lmap = None
481	# new mode is set. need to reset counters for multi page plotting
482	self._reset_counters()
483	return True
484	return False
485
486	def set_panelling(self, what=None):
487	"""Set the 'panelling' mode i.e. which type of spectra should be
488	spread across different panels.
489	"""
490
491	mode = what
492	if mode is None:
493	mode = rcParams['plotter.panelling']
494	md = self._translate(mode)
495	if md:
496	self._panelling = md
497	self._title = None
498	# new mode is set. need to reset counters for multi page plotting
499	self._reset_counters()
500	return True
501	return False
502
503	def set_layout(self,rows=None,cols=None,refresh=True):
504	"""
505	Set the multi-panel layout, i.e. how many rows and columns plots
506	are visible.
507	Parameters:
508	rows: The number of rows of plots
509	cols: The number of columns of plots
510	refresh: True (default) or False. If True, the plot is
511	replotted based on the new parameter setting(s).
512	Otherwise,the parameter(s) are set without replotting.
513	Note:
514	If no argument is given, the potter reverts to its auto-plot
515	behaviour.
516	"""
517	self._rows = rows
518	self._cols = cols
519	# new layout is set. need to reset counters for multi page plotting
520	self._reset_counters()
521	if refresh and self._data: self.plot(self._data)
522	return
523
524	def set_range(self,xstart=None,xend=None,ystart=None,yend=None,refresh=True, offset=None):
525	"""
526	Set the range of interest on the abcissa of the plot
527	Parameters:
528	[x,y]start,[x,y]end: The start and end points of the 'zoom' window
529	refresh: True (default) or False. If True, the plot is
530	replotted based on the new parameter setting(s).
531	Otherwise,the parameter(s) are set without replotting.
532	offset: shift the abcissa by the given amount. The abcissa label will
533	have '(relative)' appended to it.
534	Note:
535	These become non-sensical when the unit changes.
536	use plotter.set_range() without parameters to reset
537
538	"""
539	self._offset = offset
540	if xstart is None and xend is None:
541	self._minmaxx = None
542	else:
543	self._minmaxx = [xstart,xend]
544	if ystart is None and yend is None:
545	self._minmaxy = None
546	else:
547	self._minmaxy = [ystart,yend]
548	if refresh and self._data: self.plot(self._data)
549	return
550
551	def set_legend(self, mp=None, fontsize = None, mode = 0, refresh=True):
552	"""
553	Specify a mapping for the legend instead of using the default
554	indices:
555	Parameters:
556	mp: a list of 'strings'. This should have the same length
557	as the number of elements on the legend and then maps
558	to the indeces in order. It is possible to uses latex
559	math expression. These have to be enclosed in r'',
560	e.g. r'$x^{2}$'
561	fontsize: The font size of the label (default None)
562	mode: where to display the legend
563	Any other value for loc else disables the legend:
564	0: auto
565	1: upper right
566	2: upper left
567	3: lower left
568	4: lower right
569	5: right
570	6: center left
571	7: center right
572	8: lower center
573	9: upper center
574	10: center
575	refresh: True (default) or False. If True, the plot is
576	replotted based on the new parameter setting(s).
577	Otherwise,the parameter(s) are set without replotting.
578
579	Example:
580	If the data has two IFs/rest frequencies with index 0 and 1
581	for CO and SiO:
582	plotter.set_stacking('i')
583	plotter.set_legend(['CO','SiO'])
584	plotter.plot()
585	plotter.set_legend([r'$^{12}CO$', r'SiO'])
586	"""
587	self._lmap = mp
588	#self._plotter.legend(mode)
589	self._legendloc = mode
590	if isinstance(fontsize, int):
591	from matplotlib import rc as rcp
592	rcp('legend', fontsize=fontsize)
593	if refresh and self._data: self.plot(self._data)
594	return
595
596	def set_title(self, title=None, fontsize=None, refresh=True):
597	"""
598	Set the title of sub-plots. If multiple sub-plots are plotted,
599	multiple titles have to be specified.
600	Parameters:
601	title: a list of titles of sub-plots.
602	fontsize: a font size of titles (integer)
603	refresh: True (default) or False. If True, the plot is
604	replotted based on the new parameter setting(s).
605	Otherwise,the parameter(s) are set without replotting.
606	Example:
607	# two panels are visible on the plotter
608	plotter.set_title(['First Panel','Second Panel'])
609	"""
610	self._title = title
611	if isinstance(fontsize, int):
612	from matplotlib import rc as rcp
613	rcp('axes', titlesize=fontsize)
614	if refresh and self._data: self.plot(self._data)
615	return
616
617	def set_ordinate(self, ordinate=None, fontsize=None, refresh=True):
618	"""
619	Set the y-axis label of the plot. If multiple panels are plotted,
620	multiple labels have to be specified.
621	Parameters:
622	ordinate: a list of ordinate labels. None (default) let
623	data determine the labels
624	fontsize: a font size of vertical axis labels (integer)
625	refresh: True (default) or False. If True, the plot is
626	replotted based on the new parameter setting(s).
627	Otherwise,the parameter(s) are set without replotting.
628	Example:
629	# two panels are visible on the plotter
630	plotter.set_ordinate(['First Y-Axis','Second Y-Axis'])
631	"""
632	self._ordinate = ordinate
633	if isinstance(fontsize, int):
634	from matplotlib import rc as rcp
635	rcp('axes', labelsize=fontsize)
636	rcp('ytick', labelsize=fontsize)
637	if refresh and self._data: self.plot(self._data)
638	return
639
640	def set_abcissa(self, abcissa=None, fontsize=None, refresh=True):
641	"""
642	Set the x-axis label of the plot. If multiple panels are plotted,
643	multiple labels have to be specified.
644	Parameters:
645	abcissa: a list of abcissa labels. None (default) let
646	data determine the labels
647	fontsize: a font size of horizontal axis labels (integer)
648	refresh: True (default) or False. If True, the plot is
649	replotted based on the new parameter setting(s).
650	Otherwise,the parameter(s) are set without replotting.
651	Example:
652	# two panels are visible on the plotter
653	plotter.set_ordinate(['First X-Axis','Second X-Axis'])
654	"""
655	self._abcissa = abcissa
656	if isinstance(fontsize, int):
657	from matplotlib import rc as rcp
658	rcp('axes', labelsize=fontsize)
659	rcp('xtick', labelsize=fontsize)
660	if refresh and self._data: self.plot(self._data)
661	return
662
663	def set_histogram(self, hist=True, linewidth=None, refresh=True):
664	"""
665	Enable/Disable histogram-like plotting.
666	Parameters:
667	hist: True (default) or False. The fisrt default
668	is taken from the .asaprc setting
669	plotter.histogram
670	linewidth: a line width
671	refresh: True (default) or False. If True, the plot is
672	replotted based on the new parameter setting(s).
673	Otherwise,the parameter(s) are set without replotting.
674	"""
675	self._hist = hist
676	if isinstance(linewidth, float) or isinstance(linewidth, int):
677	from matplotlib import rc as rcp
678	rcp('lines', linewidth=linewidth)
679	if refresh and self._data: self.plot(self._data)
680
681	def set_colors(self, colmap, refresh=True):
682	"""
683	Set the colours to be used. The plotter will cycle through
684	these colours when lines are overlaid (stacking mode).
685	Parameters:
686	colmap: a list of colour names
687	refresh: True (default) or False. If True, the plot is
688	replotted based on the new parameter setting(s).
689	Otherwise,the parameter(s) are set without replotting.
690	Example:
691	plotter.set_colors('red green blue')
692	# If for example four lines are overlaid e.g I Q U V
693	# 'I' will be 'red', 'Q' will be 'green', U will be 'blue'
694	# and 'V' will be 'red' again.
695	"""
696	#if isinstance(colmap,str):
697	# colmap = colmap.split()
698	#self._plotter.palette(0, colormap=colmap)
699	self._colormap = colmap
700	if refresh and self._data: self.plot(self._data)
701
702	# alias for english speakers
703	set_colours = set_colors
704
705	def set_linestyles(self, linestyles=None, linewidth=None, refresh=True):
706	"""
707	Set the linestyles to be used. The plotter will cycle through
708	these linestyles when lines are overlaid (stacking mode) AND
709	only one color has been set.
710	Parameters:
711	linestyles: a list of linestyles to use.
712	'line', 'dashed', 'dotted', 'dashdot',
713	'dashdotdot' and 'dashdashdot' are
714	possible
715	linewidth: a line width
716	refresh: True (default) or False. If True, the plot is
717	replotted based on the new parameter setting(s).
718	Otherwise,the parameter(s) are set without replotting.
719	Example:
720	plotter.set_colors('black')
721	plotter.set_linestyles('line dashed dotted dashdot')
722	# If for example four lines are overlaid e.g I Q U V
723	# 'I' will be 'solid', 'Q' will be 'dashed',
724	# U will be 'dotted' and 'V' will be 'dashdot'.
725	"""
726	#if isinstance(linestyles,str):
727	# linestyles = linestyles.split()
728	#self._plotter.palette(color=0,linestyle=0,linestyles=linestyles)
729	self._linestyles = linestyles
730	if isinstance(linewidth, float) or isinstance(linewidth, int):
731	from matplotlib import rc as rcp
732	rcp('lines', linewidth=linewidth)
733	if refresh and self._data: self.plot(self._data)
734
735	def set_font(self, refresh=True,**kwargs):
736	"""
737	Set font properties.
738	Parameters:
739	family: one of 'sans-serif', 'serif', 'cursive', 'fantasy', 'monospace'
740	style: one of 'normal' (or 'roman'), 'italic' or 'oblique'
741	weight: one of 'normal or 'bold'
742	size: the 'general' font size, individual elements can be adjusted
743	seperately
744	refresh: True (default) or False. If True, the plot is
745	replotted based on the new parameter setting(s).
746	Otherwise,the parameter(s) are set without replotting.
747	"""
748	from matplotlib import rc as rcp
749	fdict = {}
750	for k,v in kwargs.iteritems():
751	if v:
752	fdict[k] = v
753	self._fp = FontProperties(**fdict)
754	if refresh and self._data: self.plot(self._data)
755
756	def set_margin(self,margin=[],refresh=True):
757	"""
758	Set margins between subplots and plot edges.
759	Parameters:
760	margin: a list of margins in figure coordinate (0-1),
761	i.e., fraction of the figure width or height.
762	The order of elements should be:
763	[left, bottom, right, top, horizontal space btw panels,
764	vertical space btw panels].
765	refresh: True (default) or False. If True, the plot is
766	replotted based on the new parameter setting(s).
767	Otherwise,the parameter(s) are set without replotting.
768	Note
769	* When margin is not specified, the values are reset to the defaults
770	of matplotlib.
771	* If any element is set to be None, the current value is adopted.
772	"""
773	if margin == []: self._margins=self._reset_margin()
774	else:
775	self._margins=[None]*6
776	self._margins[0:len(margin)]=margin
777	#print "panel margin set to ",self._margins
778	if refresh and self._data: self.plot(self._data)
779
780	def _reset_margin(self):
781	ks=map(lambda x: 'figure.subplot.'+x,
782	['left','bottom','right','top','hspace','wspace'])
783	return map(matplotlib.rcParams.get,ks)
784
785	def plot_lines(self, linecat=None, doppler=0.0, deltachan=10, rotate=90.0,
786	location=None):
787	"""
788	Plot a line catalog.
789	Parameters:
790	linecat: the linecatalog to plot
791	doppler: the velocity shift to apply to the frequencies
792	deltachan: the number of channels to include each side of the
793	line to determine a local maximum/minimum
794	rotate: the rotation (in degrees) for the text label (default 90.0)
795	location: the location of the line annotation from the 'top',
796	'bottom' or alternate (None - the default)
797	Notes:
798	If the spectrum is flagged no line will be drawn in that location.
799	"""
800	errmsg = "Cannot plot spectral lines. Need to plot scantable first."
801	self._assert_plotter(action="halt",errmsg=errmsg)
802	if not self._data:
803	raise RuntimeError("No scantable has been plotted yet.")
804	from asap._asap import linecatalog
805	if not isinstance(linecat, linecatalog):
806	raise ValueError("'linecat' isn't of type linecatalog.")
807	if not self._data.get_unit().endswith("Hz"):
808	raise RuntimeError("Can only overlay linecatalogs when data is in frequency.")
809	from numpy import ma
810	for j in range(len(self._plotter.subplots)):
811	self._plotter.subplot(j)
812	lims = self._plotter.axes.get_xlim()
813	for row in range(linecat.nrow()):
814	# get_frequency returns MHz
815	base = { "GHz": 1000.0, "MHz": 1.0, "Hz": 1.0e-6 }
816	restf = linecat.get_frequency(row)/base[self._data.get_unit()]
817	c = 299792.458
818	freq = restf*(1.0-doppler/c)
819	if lims[0] < freq < lims[1]:
820	if location is None:
821	loc = 'bottom'
822	if row%2: loc='top'
823	else: loc = location
824	maxys = []
825	for line in self._plotter.axes.lines:
826	v = line._x
827	asc = v[0] < v[-1]
828
829	idx = None
830	if not asc:
831	if v[len(v)-1] <= freq <= v[0]:
832	i = len(v)-1
833	while i>=0 and v[i] < freq:
834	idx = i
835	i-=1
836	else:
837	if v[0] <= freq <= v[len(v)-1]:
838	i = 0
839	while i<len(v) and v[i] < freq:
840	idx = i
841	i+=1
842	if idx is not None:
843	lower = idx - deltachan
844	upper = idx + deltachan
845	if lower < 0: lower = 0
846	if upper > len(v): upper = len(v)
847	s = slice(lower, upper)
848	y = line._y[s]
849	maxy = ma.maximum(y)
850	if isinstance( maxy, float):
851	maxys.append(maxy)
852	if len(maxys):
853	peak = max(maxys)
854	if peak > self._plotter.axes.get_ylim()[1]:
855	loc = 'bottom'
856	else:
857	continue
858	self._plotter.vline_with_label(freq, peak,
859	linecat.get_name(row),
860	location=loc, rotate=rotate)
861	self._plotter.show(hardrefresh=False)
862
863
864	def set_selection(self, selection=None, refresh=True, **kw):
865	"""
866	Parameters:
867	selection: a selector object (default unset the selection)
868	refresh: True (default) or False. If True, the plot is
869	replotted based on the new parameter setting(s).
870	Otherwise,the parameter(s) are set without replotting.
871	"""
872	if selection is None:
873	# reset
874	if len(kw) == 0:
875	self._selection = selector()
876	else:
877	# try keywords
878	for k in kw:
879	if k not in selector.fields:
880	raise KeyError("Invalid selection key '%s', valid keys are %s" % (k, selector.fields))
881	self._selection = selector(**kw)
882	elif isinstance(selection, selector):
883	self._selection = selection
884	else:
885	raise TypeError("'selection' is not of type selector")
886
887	order = self._get_sortstring([self._panelling,self._stacking])
888	if order:
889	self._selection.set_order(order)
890	if refresh and self._data:
891	self.plot()
892
893	@asaplog_post_dec
894	def set_mask(self, mask=None, selection=None, refresh=True):
895	"""
896	Set a plotting mask for a specific polarization.
897	This is useful for masking out 'noise' Pangle outside a source.
898	Parameters:
899	mask: a mask from scantable.create_mask
900	selection: the spectra to apply the mask to.
901	refresh: True (default) or False. If True, the plot is
902	replotted based on the new parameter setting(s).
903	Otherwise,the parameter(s) are set without replotting.
904	Example:
905	select = selector()
906	select.setpolstrings('Pangle')
907	plotter.set_mask(mymask, select)
908	"""
909	if not self._data:
910	msg = "Can only set mask after a first call to plot()"
911	raise RuntimeError(msg)
912	if (mask is not None) and len(mask):
913	if isinstance(mask, list) or isinstance(mask, tuple):
914	self._usermask = array(mask)
915	else:
916	self._usermask = mask
917	if mask is None and selection is None:
918	self._usermask = []
919	self._maskselection = None
920	if isinstance(selection, selector):
921	self._maskselection = {'b': selection.get_beams(),
922	's': selection.get_scans(),
923	'i': selection.get_ifs(),
924	'p': selection.get_pols(),
925	't': [] }
926	else:
927	self._maskselection = None
928	if refresh: self.plot(self._data)
929
930
931	### Reset methods ###
932	def _reset(self):
933	"""Reset method called when new data is set"""
934	# reset selections and masks
935	self.set_selection(None, False)
936	self.set_mask(None, None, False)
937	# reset offset
938	self._offset = None
939	# reset header
940	self._reset_header()
941	# reset labels
942	self._lmap = None # related to stack
943	self.set_title(None, None, False)
944	self.set_ordinate(None, None, False)
945	self.set_abcissa(None, None, False)
946
947	def _reset_header(self):
948	self._headtext={'string': None, 'textobj': None}
949
950	def _reset_counter(self):
951	self._startrow = 0
952	self._ipanel = -1
953	self._panelrows = []
954	self._reset_header()
955	if self.casabar_exists():
956	self._plotter.figmgr.casabar.set_pagecounter(1)
957
958	def _reset_counters(self):
959	self._startrow = 0
960	self._ipanel = -1
961	self._panelrows = []
962
963
964	### Actual scantable plot methods ###
965	@asaplog_post_dec
966	def plot(self, scan=None):
967	"""
968	Plot a scantable.
969	Parameters:
970	scan: a scantable
971	Note:
972	If a scantable was specified in a previous call
973	to plot, no argument has to be given to 'replot'
974	NO checking is done that the abcissas of the scantable
975	are consistent e.g. all 'channel' or all 'velocity' etc.
976	"""
977	self._plotmode = "spectra"
978	if not self._data and not scan:
979	msg = "Input is not a scantable"
980	raise TypeError(msg)
981
982	self._assert_plotter(action="reload")
983	self._plotter.hold()
984	self._reset_counter()
985	#self._plotter.clear()
986	if scan:
987	self.set_data(scan, refresh=False)
988	self._plotter.palette(color=0,colormap=self._colormap,
989	linestyle=0,linestyles=self._linestyles)
990	self._plotter.legend(self._legendloc)
991	self._plot(self._data)
992	if self._minmaxy is not None:
993	self._plotter.set_limits(ylim=self._minmaxy)
994	if self.casabar_exists(): self._plotter.figmgr.casabar.enable_button()
995	self._plotter.release()
996	self._plotter.tidy()
997	self._plotter.show(hardrefresh=False)
998	return
999
1000	def _plot(self, scan):
1001	savesel = scan.get_selection()
1002	sel = savesel + self._selection
1003	order = self._get_sortstring([self._panelling,self._stacking])
1004	if order:
1005	sel.set_order(order)
1006	scan.set_selection(sel)
1007	d = {'b': scan.getbeam, 's': scan.getscan,
1008	'i': scan.getif, 'p': scan.getpol, 't': scan.get_time,
1009	'r': int}#, '_r': int}
1010
1011	polmodes = dict(zip(sel.get_pols(), sel.get_poltypes()))
1012	# this returns either a tuple of numbers or a length (ncycles)
1013	# convert this into lengths
1014	n0,nstack0 = self._get_selected_n(scan)
1015	if isinstance(n0, int): n = n0
1016	else: n = len(n0)
1017	if isinstance(nstack0, int): nstack = nstack0
1018	else: nstack = len(nstack0)
1019	# In case of row stacking
1020	rowstack = False
1021	titlemode = self._panelling
1022	if self._stacking == "r" and self._panelling != "r":
1023	rowstack = True
1024	titlemode = '_r'
1025	nptot = n
1026	maxpanel, maxstack = 16,16
1027	if nstack > maxstack:
1028	msg ="Scan to be overlayed contains more than %d selections.\n" \
1029	"Selecting first %d selections..." % (maxstack, maxstack)
1030	asaplog.push(msg)
1031	asaplog.post('WARN')
1032	nstack = min(nstack,maxstack)
1033	#n = min(n-self._ipanel-1,maxpanel)
1034	n = n-self._ipanel-1
1035	# the number of panels in this page
1036	if self._rows and self._cols:
1037	n = min(n,self._rows*self._cols)
1038	else:
1039	n = min(n,maxpanel)
1040
1041	firstpage = (self._ipanel < 0)
1042	#ganged = False
1043	ganged = rcParams['plotter.ganged']
1044	if self._panelling == 'i':
1045	ganged = False
1046	if (not firstpage) and \
1047	self._plotter._subplotsOk(self._rows, self._cols, n):
1048	# Not the first page and subplot number is ok.
1049	# Just clear the axis
1050	nx = self._plotter.cols
1051	ipaxx = n - nx - 1 #the max panel id to supress x-label
1052	for ip in xrange(len(self._plotter.subplots)):
1053	self._plotter.subplot(ip)
1054	self._plotter.clear()
1055	self._plotter.axes.set_visible((ip<n))
1056	if ganged:
1057	self._plotter.axes.xaxis.label.set_visible((ip > ipaxx))
1058	if ip <= ipaxx:
1059	map(lambda x: x.set_visible(False), \
1060	self._plotter.axes.get_xticklabels())
1061	self._plotter.axes.yaxis.label.set_visible((ip % nx)==0)
1062	if ip % nx:
1063	map(lambda y: y.set_visible(False), \
1064	self._plotter.axes.get_yticklabels())
1065	elif (n > 1 and self._rows and self._cols):
1066	self._plotter.set_panels(rows=self._rows,cols=self._cols,
1067	nplots=n,margin=self._margins,
1068	ganged=ganged)
1069	else:
1070	self._plotter.set_panels(rows=n,cols=0,nplots=n,
1071	margin=self._margins,ganged=ganged)
1072	#r = 0
1073	r = self._startrow
1074	nr = scan.nrow()
1075	a0,b0 = -1,-1
1076	allxlim = []
1077	allylim = []
1078	#newpanel=True
1079	newpanel=False
1080	panelcount,stackcount = 0,0
1081	# If this is not the first page
1082	if r > 0:
1083	# panelling value of the prev page
1084	a0 = d[self._panelling](r-1)
1085	# set the initial stackcount large not to plot
1086	# the start row automatically
1087	stackcount = nstack
1088
1089	while r < nr:
1090	a = d[self._panelling](r)
1091	b = d[self._stacking](r)
1092	if a > a0 and panelcount < n:
1093	if n > 1:
1094	self._plotter.subplot(panelcount)
1095	self._plotter.palette(0)
1096	#title
1097	xlab = self._abcissa and self._abcissa[panelcount] \
1098	or scan._getabcissalabel()
1099	if self._offset and not self._abcissa:
1100	xlab += " (relative)"
1101	ylab = self._ordinate and self._ordinate[panelcount] \
1102	or scan._get_ordinate_label()
1103	self._plotter.set_axes('xlabel', xlab)
1104	self._plotter.set_axes('ylabel', ylab)
1105	#lbl = self._get_label(scan, r, self._panelling, self._title)
1106	lbl = self._get_label(scan, r, titlemode, self._title)
1107	if isinstance(lbl, list) or isinstance(lbl, tuple):
1108	if 0 <= panelcount < len(lbl):
1109	lbl = lbl[panelcount]
1110	else:
1111	# get default label
1112	#lbl = self._get_label(scan, r, self._panelling, None)
1113	lbl = self._get_label(scan, r, titlemode, None)
1114	self._plotter.set_axes('title',lbl)
1115	newpanel = True
1116	stackcount = 0
1117	panelcount += 1
1118	# save the start row to plot this panel for future revisit.
1119	if self._panelling != 'r' and \
1120	len(self._panelrows) < self._ipanel+1+panelcount:
1121	self._panelrows += [r]
1122
1123	#if (b > b0 or newpanel) and stackcount < nstack:
1124	if stackcount < nstack and (newpanel or \
1125	rowstack or (a == a0 and b > b0)):
1126	y = []
1127	if len(polmodes):
1128	y = scan._getspectrum(r, polmodes[scan.getpol(r)])
1129	else:
1130	y = scan._getspectrum(r)
1131	# flag application
1132	mr = scan._getflagrow(r)
1133	from numpy import ma, array
1134	if mr:
1135	y = ma.masked_array(y,mask=mr)
1136	else:
1137	m = scan._getmask(r)
1138	from numpy import logical_not, logical_and
1139	if self._maskselection and len(self._usermask) == len(m):
1140	if d[self._stacking](r) in self._maskselection[self._stacking]:
1141	m = logical_and(m, self._usermask)
1142	y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
1143
1144	x = array(scan._getabcissa(r))
1145	if self._offset:
1146	x += self._offset
1147	if self._minmaxx is not None:
1148	s,e = self._slice_indeces(x)
1149	x = x[s:e]
1150	y = y[s:e]
1151	if len(x) > 1024 and rcParams['plotter.decimate']:
1152	fac = len(x)/1024
1153	x = x[::fac]
1154	y = y[::fac]
1155	llbl = self._get_label(scan, r, self._stacking, self._lmap)
1156	if isinstance(llbl, list) or isinstance(llbl, tuple):
1157	if 0 <= stackcount < len(llbl):
1158	# use user label
1159	llbl = llbl[stackcount]
1160	else:
1161	# get default label
1162	llbl = self._get_label(scan, r, self._stacking, None)
1163	self._plotter.set_line(label=llbl)
1164	plotit = self._plotter.plot
1165	if self._hist: plotit = self._plotter.hist
1166	if len(x) > 0 and not mr:
1167	plotit(x,y)
1168	xlim= self._minmaxx or [min(x),max(x)]
1169	allxlim += xlim
1170	ylim= self._minmaxy or [ma.minimum(y),ma.maximum(y)]
1171	allylim += ylim
1172	else:
1173	xlim = self._minmaxx or []
1174	allxlim += xlim
1175	ylim= self._minmaxy or []
1176	allylim += ylim
1177	stackcount += 1
1178	a0=a
1179	b0=b
1180	# last in colour stack -> autoscale x
1181	if stackcount == nstack and len(allxlim) > 0:
1182	allxlim.sort()
1183	self._plotter.subplots[panelcount-1]['axes'].set_xlim([allxlim[0],allxlim[-1]])
1184	if ganged:
1185	allxlim = [allxlim[0],allxlim[-1]]
1186	else:
1187	# clear
1188	allxlim =[]
1189
1190	newpanel = False
1191	#a0=a
1192	#b0=b
1193	# ignore following rows
1194	if (panelcount == n and stackcount == nstack) or (r == nr-1):
1195	# last panel -> autoscale y if ganged
1196	#if rcParams['plotter.ganged'] and len(allylim) > 0:
1197	if ganged and len(allylim) > 0:
1198	allylim.sort()
1199	self._plotter.set_limits(ylim=[allylim[0],allylim[-1]])
1200	break
1201	r+=1 # next row
1202
1203	# save the current counter for multi-page plotting
1204	self._startrow = r+1
1205	self._ipanel += panelcount
1206	if self.casabar_exists():
1207	if self._ipanel >= nptot-1:
1208	self._plotter.figmgr.casabar.disable_next()
1209	else:
1210	self._plotter.figmgr.casabar.enable_next()
1211	if self._ipanel + 1 - panelcount > 0:
1212	self._plotter.figmgr.casabar.enable_prev()
1213	else:
1214	self._plotter.figmgr.casabar.disable_prev()
1215
1216	#reset the selector to the scantable's original
1217	scan.set_selection(savesel)
1218
1219	#temporary switch-off for older matplotlib
1220	#if self._fp is not None:
1221	if self._fp is not None and \
1222	getattr(self._plotter.figure,'findobj',False):
1223	for o in self._plotter.figure.findobj(Text):
1224	if not self._headtext['textobj'] or \
1225	not (o in self._headtext['textobj']):
1226	o.set_fontproperties(self._fp)
1227
1228	def _get_sortstring(self, lorders):
1229	d0 = {'s': 'SCANNO', 'b': 'BEAMNO', 'i':'IFNO',
1230	'p': 'POLNO', 'c': 'CYCLENO', 't' : 'TIME', 'r':None, '_r':None }
1231	if not (type(lorders) == list) and not (type(lorders) == tuple):
1232	return None
1233	if len(lorders) > 0:
1234	lsorts = []
1235	for order in lorders:
1236	if order == "r":
1237	# don't sort if row panelling/stacking
1238	return None
1239	ssort = d0[order]
1240	if ssort:
1241	lsorts.append(ssort)
1242	return lsorts
1243	return None
1244
1245	def _get_selected_n(self, scan):
1246	d1 = {'b': scan.getbeamnos, 's': scan.getscannos,
1247	'i': scan.getifnos, 'p': scan.getpolnos, 't': scan.ncycle,
1248	'r': scan.nrow}#, '_r': False}
1249	d2 = { 'b': self._selection.get_beams(),
1250	's': self._selection.get_scans(),
1251	'i': self._selection.get_ifs(),
1252	'p': self._selection.get_pols(),
1253	't': self._selection.get_cycles(),
1254	'r': False}#, '_r': 1}
1255	n = d2[self._panelling] or d1[self._panelling]()
1256	nstack = d2[self._stacking] or d1[self._stacking]()
1257	# handle row panelling/stacking
1258	if self._panelling == 'r':
1259	nstack = 1
1260	elif self._stacking == 'r':
1261	n = 1
1262	return n,nstack
1263
1264	def _get_label(self, scan, row, mode, userlabel=None):
1265	if isinstance(userlabel, list) and len(userlabel) == 0:
1266	userlabel = " "
1267	pms = dict(zip(self._selection.get_pols(),self._selection.get_poltypes()))
1268	if len(pms):
1269	poleval = scan._getpollabel(scan.getpol(row),pms[scan.getpol(row)])
1270	else:
1271	poleval = scan._getpollabel(scan.getpol(row),scan.poltype())
1272	d = {'b': "Beam "+str(scan.getbeam(row)),
1273	#'s': scan._getsourcename(row),
1274	's': "Scan "+str(scan.getscan(row))+\
1275	" ("+str(scan._getsourcename(row))+")",
1276	'i': "IF"+str(scan.getif(row)),
1277	'p': poleval,
1278	't': str(scan.get_time(row)),
1279	'r': "row "+str(row),
1280	#'_r': str(scan.get_time(row))+",\nIF"+str(scan.getif(row))+", "+poleval+", Beam"+str(scan.getbeam(row)) }
1281	'_r': "" }
1282	return userlabel or d[mode]
1283
1284	def _slice_indeces(self, data):
1285	mn = self._minmaxx[0]
1286	mx = self._minmaxx[1]
1287	asc = data[0] < data[-1]
1288	start=0
1289	end = len(data)-1
1290	inc = 1
1291	if not asc:
1292	start = len(data)-1
1293	end = 0
1294	inc = -1
1295	# find min index
1296	#while start > 0 and data[start] < mn:
1297	# start+= inc
1298	minind=start
1299	for ind in xrange(start,end+inc,inc):
1300	if data[ind] > mn: break
1301	minind=ind
1302	# find max index
1303	#while end > 0 and data[end] > mx:
1304	# end-=inc
1305	#if end > 0: end +=1
1306	maxind=end
1307	for ind in xrange(end,start-inc,-inc):
1308	if data[ind] < mx: break
1309	maxind=ind
1310	start=minind
1311	end=maxind
1312	if start > end:
1313	return end,start+1
1314	elif start < end:
1315	return start,end+1
1316	else:
1317	return start,end
1318
1319	def plotazel(self, scan=None, outfile=None):
1320	"""
1321	plot azimuth and elevation versus time of a scantable
1322	"""
1323	self._plotmode = "azel"
1324	visible = rcParams['plotter.gui']
1325	from matplotlib import pylab as PL
1326	from matplotlib.dates import DateFormatter
1327	from pytz import timezone
1328	from matplotlib.dates import HourLocator, MinuteLocator,SecondLocator, DayLocator
1329	from matplotlib.ticker import MultipleLocator
1330	from numpy import array, pi, ma
1331	if self._plotter and (PL.gcf() == self._plotter.figure):
1332	# the current figure is ASAP plotter. Use mpl plotter
1333	figids = PL.get_fignums()
1334	PL.figure(max(figids[-1],1))
1335
1336	if not visible or not self._visible:
1337	PL.ioff()
1338	from matplotlib.backends.backend_agg import FigureCanvasAgg
1339	PL.gcf().canvas.switch_backends(FigureCanvasAgg)
1340	self._data = scan
1341	dates = self._data.get_time(asdatetime=True)
1342	# for flag handling
1343	mask = [ self._data._is_all_chan_flagged(i) for i in range(self._data.nrow())]
1344	t = PL.date2num(dates)
1345	tz = timezone('UTC')
1346	PL.cla()
1347	PL.ioff()
1348	PL.clf()
1349	# Adjust subplot margins
1350	if not self._margins or len(self._margins) != 6:
1351	self.set_margin(refresh=False)
1352	lef, bot, rig, top, wsp, hsp = self._margins
1353	PL.gcf().subplots_adjust(left=lef,bottom=bot,right=rig,top=top,
1354	wspace=wsp,hspace=hsp)
1355
1356	tdel = max(t) - min(t) # interval in day
1357	ax = PL.subplot(2,1,1)
1358	el = ma.masked_array(array(self._data.get_elevation())*180./pi, mask)
1359	PL.ylabel('El [deg.]')
1360	dstr = dates[0].strftime('%Y/%m/%d')
1361	if tdel > 1.0: # >1day
1362	dstr2 = dates[len(dates)-1].strftime('%Y/%m/%d')
1363	dstr = dstr + " - " + dstr2
1364	majloc = DayLocator()
1365	minloc = HourLocator(range(0,23,12))
1366	timefmt = DateFormatter("%b%d")
1367	elif tdel > 24./60.: # 9.6h - 1day
1368	timefmt = DateFormatter('%H:%M')
1369	majloc = HourLocator()
1370	minloc = MinuteLocator(range(0,60,30))
1371	elif tdel > 2./24.: # 2h-9.6h
1372	timefmt = DateFormatter('%H:%M')
1373	majloc = HourLocator()
1374	minloc = MinuteLocator(range(0,60,10))
1375	elif tdel> 10./24./60.: # 10min-2h
1376	timefmt = DateFormatter('%H:%M')
1377	majloc = MinuteLocator(range(0,60,10))
1378	minloc = MinuteLocator()
1379	else: # <10min
1380	timefmt = DateFormatter('%H:%M')
1381	majloc = MinuteLocator()
1382	minloc = SecondLocator(30)
1383
1384	PL.title(dstr)
1385	if tdel == 0.0:
1386	th = (t - PL.floor(t))*24.0
1387	PL.plot(th,el,'o',markersize=2, markerfacecolor='b', markeredgecolor='b')
1388	else:
1389	PL.plot_date(t,el,'o', markersize=2, markerfacecolor='b', markeredgecolor='b',tz=tz)
1390	#ax.grid(True)
1391	ax.xaxis.set_major_formatter(timefmt)
1392	ax.xaxis.set_major_locator(majloc)
1393	ax.xaxis.set_minor_locator(minloc)
1394	ax.yaxis.grid(True)
1395	yloc = MultipleLocator(30)
1396	ax.set_ylim(0,90)
1397	ax.yaxis.set_major_locator(yloc)
1398	if tdel > 1.0:
1399	labels = ax.get_xticklabels()
1400	# PL.setp(labels, fontsize=10, rotation=45)
1401	PL.setp(labels, fontsize=10)
1402
1403	# Az plot
1404	az = ma.masked_array(array(self._data.get_azimuth())*180./pi, mask)
1405	if min(az) < 0:
1406	for irow in range(len(az)):
1407	if az[irow] < 0: az[irow] += 360.0
1408
1409	ax2 = PL.subplot(2,1,2)
1410	#PL.xlabel('Time (UT [hour])')
1411	PL.ylabel('Az [deg.]')
1412	if tdel == 0.0:
1413	PL.plot(th,az,'o',markersize=2, markeredgecolor='b',markerfacecolor='b')
1414	else:
1415	PL.plot_date(t,az,'o', markersize=2,markeredgecolor='b',markerfacecolor='b',tz=tz)
1416	ax2.xaxis.set_major_formatter(timefmt)
1417	ax2.xaxis.set_major_locator(majloc)
1418	ax2.xaxis.set_minor_locator(minloc)
1419	#ax2.grid(True)
1420	ax2.set_ylim(0,360)
1421	ax2.yaxis.grid(True)
1422	#hfmt = DateFormatter('%H')
1423	#hloc = HourLocator()
1424	yloc = MultipleLocator(60)
1425	ax2.yaxis.set_major_locator(yloc)
1426	if tdel > 1.0:
1427	labels = ax2.get_xticklabels()
1428	PL.setp(labels, fontsize=10)
1429	PL.xlabel('Time (UT [day])')
1430	else:
1431	PL.xlabel('Time (UT [hour])')
1432
1433	PL.ion()
1434	PL.draw()
1435	if matplotlib.get_backend() == 'Qt4Agg': PL.gcf().show()
1436	if (outfile is not None):
1437	PL.savefig(outfile)
1438
1439
1440	def plotpointing2(self, scan=None, colorby='', showline=False, projection=''):
1441	"""
1442	plot telescope pointings
1443	Parameters:
1444	infile : input filename or scantable instance
1445	colorby : change color by either
1446	'type'(source type)\|'scan'\|'if'\|'pol'\|'beam'
1447	showline : show dotted line
1448	projection : projection type either
1449	''(no projection [deg])\|'coord'(not implemented)
1450	"""
1451	self._plotmode = "pointing"
1452	from numpy import array, pi, ma
1453	from asap import scantable
1454	# check for scantable
1455	if isinstance(scan, scantable):
1456	if self._data is not None:
1457	if scan != self._data:
1458	self._data = scan
1459	# reset
1460	self._reset()
1461	else:
1462	self._data = scan
1463	self._reset()
1464	if not self._data:
1465	msg = "Input is not a scantable"
1466	raise TypeError(msg)
1467	# check for color mode
1468	validtypes=['type','scan','if','pol', 'beam']
1469	stype = None
1470	if (colorby in validtypes):
1471	stype = colorby[0]
1472	elif len(colorby) > 0:
1473	msg = "Invalid choice of 'colorby' (choices: %s)" % str(validtypes)
1474	raise ValueError(msg)
1475	self._assert_plotter(action="reload")
1476	self._plotter.hold()
1477	self._reset_counter()
1478	if self.casabar_exists():
1479	self._plotter.figmgr.casabar.disable_button()
1480	# for now, only one plot
1481	self._plotter.set_panels(rows=1,cols=1)
1482	# first panel
1483	self._plotter.subplot(0)
1484	# first color and linestyles
1485	self._plotter.palette(0)
1486	self.gca().set_aspect('equal')
1487	basesel = scan.get_selection()
1488	attrback = self._plotter.get_line()
1489	marker = "o"
1490	if showline:
1491	basesel.set_order(["TIME"])
1492	scan.set_selection(basesel)
1493	if not (stype in ["t", "s"]):
1494	marker += ":"
1495	self._plotter.set_line(markersize=3, markeredgewidth=0)
1496
1497	if not stype:
1498	selIds = [""] # cheating
1499	sellab = "all points"
1500	elif stype == 't':
1501	selIds = range(15)
1502	sellab = "src type "
1503	else:
1504	selIds = getattr(self._data,'get'+colorby+'nos')()
1505	sellab = colorby.upper()
1506	selFunc = "set_"+colorby+"s"
1507	for idx in selIds:
1508	sel = selector() + basesel
1509	if stype:
1510	bid = getattr(basesel,'get_'+colorby+"s")()
1511	if (len(bid) > 0) and (not idx in bid):
1512	# base selection doesn't contain idx
1513	# Note summation of selector is logical sum if
1514	continue
1515	getattr(sel, selFunc)([idx])
1516	if not sel.is_empty():
1517	try:
1518	self._data.set_selection(sel)
1519	except RuntimeError, instance:
1520	if stype == 't' and str(instance).startswith("Selection contains no data."):
1521	continue
1522	else:
1523	self._data.set_selection(basesel)
1524	raise RuntimeError, instance
1525	if self._data.nrow() == 0:
1526	self._data.set_selection(basesel)
1527	continue
1528	#print "Plotting direction of %s = %s" % (colorby, str(idx))
1529	# getting data to plot
1530	dir = array(self._data.get_directionval()).transpose()
1531	# for flag handling
1532	mask = [ self._data._is_all_chan_flagged(i) for i in range(self._data.nrow())]
1533	ra = dir[0]*180./pi
1534	dec = ma.masked_array(dir[1]*180./pi, mask)
1535	# actual plot
1536	self._plotter.set_line(label=(sellab+str(idx)))
1537	self._plotter.plot(ra,dec,marker)
1538
1539	# restore original selection
1540	self._data.set_selection(basesel)
1541	# need to plot scan pattern explicitly
1542	if showline and (stype in ["t", "s"]):
1543	dir = array(self._data.get_directionval()).transpose()
1544	ra = dir[0]*180./pi
1545	dec = dir[1]*180./pi
1546	self._plotter.set_line(label="scan pattern")
1547	self._plotter.plot(ra,dec,":")
1548	# set color for only this line
1549	self._plotter.lines[-1][0].set_color("gray")
1550
1551	xlab = 'RA [deg.]'
1552	ylab = 'Declination [deg.]'
1553	self._plotter.set_axes('xlabel', xlab)
1554	self._plotter.set_axes('ylabel', ylab)
1555	self._plotter.set_axes('title', 'Telescope pointings')
1556	if stype: self._plotter.legend(self._legendloc)
1557	else: self._plotter.legend(None)
1558	# reverse x-axis
1559	xmin, xmax = self.gca().get_xlim()
1560	self._plotter.set_limits(xlim=[xmax,xmin])
1561
1562	self._plotter.release()
1563	self._plotter.show(hardrefresh=False)
1564	# reset line settings
1565	self._plotter.set_line(**attrback)
1566	return
1567
1568	def plotpointing(self, scan=None, outfile=None):
1569	"""
1570	plot telescope pointings
1571	"""
1572	visible = rcParams['plotter.gui']
1573	from matplotlib import pylab as PL
1574	from numpy import array, pi
1575	if self._plotter and (PL.gcf() == self._plotter.figure):
1576	# the current figure is ASAP plotter. Use mpl plotter
1577	figids = PL.get_fignums()
1578	PL.figure(max(figids[-1],1))
1579
1580	if not visible or not self._visible:
1581	PL.ioff()
1582	from matplotlib.backends.backend_agg import FigureCanvasAgg
1583	PL.gcf().canvas.switch_backends(FigureCanvasAgg)
1584	self._data = scan
1585	dir = array(self._data.get_directionval()).transpose()
1586	ra = dir[0]*180./pi
1587	dec = dir[1]*180./pi
1588	PL.cla()
1589	#PL.ioff()
1590	PL.clf()
1591	# Adjust subplot margins
1592	if not self._margins or len(self._margins) != 6:
1593	self.set_margin(refresh=False)
1594	lef, bot, rig, top, wsp, hsp = self._margins
1595	PL.gcf().subplots_adjust(left=lef,bottom=bot,right=rig,top=top,
1596	wspace=wsp,hspace=hsp)
1597	ax = PL.gca()
1598	#ax = PL.axes([0.1,0.1,0.8,0.8])
1599	#ax = PL.axes([0.1,0.1,0.8,0.8])
1600	ax.set_aspect('equal')
1601	PL.plot(ra, dec, 'b,')
1602	PL.xlabel('RA [deg.]')
1603	PL.ylabel('Declination [deg.]')
1604	PL.title('Telescope pointings')
1605	[xmin,xmax,ymin,ymax] = PL.axis()
1606	PL.axis([xmax,xmin,ymin,ymax])
1607	PL.ion()
1608	PL.draw()
1609	if matplotlib.get_backend() == 'Qt4Agg': PL.gcf().show()
1610	if (outfile is not None):
1611	PL.savefig(outfile)
1612
1613	# plot total power data
1614	# plotting in time is not yet implemented..
1615	@asaplog_post_dec
1616	def plottp(self, scan=None):
1617	self._plotmode = "totalpower"
1618	from asap import scantable
1619	if not self._data and not scan:
1620	msg = "Input is not a scantable"
1621	raise TypeError(msg)
1622	if isinstance(scan, scantable):
1623	if self._data is not None:
1624	if scan != self._data:
1625	self._data = scan
1626	# reset
1627	self._reset()
1628	else:
1629	self._data = scan
1630	self._reset()
1631	# ranges become invalid when abcissa changes?
1632	#if self._abcunit and self._abcunit != self._data.get_unit():
1633	# self._minmaxx = None
1634	# self._minmaxy = None
1635	# self._abcunit = self._data.get_unit()
1636
1637	self._assert_plotter(action="reload")
1638	self._plotter.hold()
1639	self._plotter.clear()
1640	# Adjust subplot margins
1641	if not self._margins or len(self._margins) !=6:
1642	self.set_margin(refresh=False)
1643	lef, bot, rig, top, wsp, hsp = self._margins
1644	self._plotter.figure.subplots_adjust(
1645	left=lef,bottom=bot,right=rig,top=top,wspace=wsp,hspace=hsp)
1646	if self.casabar_exists(): self._plotter.figmgr.casabar.disable_button()
1647	self._plottp(self._data)
1648	if self._minmaxy is not None:
1649	self._plotter.set_limits(ylim=self._minmaxy)
1650	self._plotter.release()
1651	self._plotter.tidy()
1652	self._plotter.show(hardrefresh=False)
1653	return
1654
1655	def _plottp(self,scan):
1656	"""
1657	private method for plotting total power data
1658	"""
1659	from numpy import ma, array, arange, logical_not
1660	r=0
1661	nr = scan.nrow()
1662	a0,b0 = -1,-1
1663	allxlim = []
1664	allylim = []
1665	y=[]
1666	self._plotter.set_panels()
1667	self._plotter.palette(0)
1668	#title
1669	#xlab = self._abcissa and self._abcissa[panelcount] \
1670	# or scan._getabcissalabel()
1671	#ylab = self._ordinate and self._ordinate[panelcount] \
1672	# or scan._get_ordinate_label()
1673	xlab = self._abcissa or 'row number' #or Time
1674	ylab = self._ordinate or scan._get_ordinate_label()
1675	self._plotter.set_axes('xlabel',xlab)
1676	self._plotter.set_axes('ylabel',ylab)
1677	lbl = self._get_label(scan, r, 's', self._title)
1678	if isinstance(lbl, list) or isinstance(lbl, tuple):
1679	# if 0 <= panelcount < len(lbl):
1680	# lbl = lbl[panelcount]
1681	# else:
1682	# get default label
1683	lbl = self._get_label(scan, r, self._panelling, None)
1684	self._plotter.set_axes('title',lbl)
1685	y=array(scan._get_column(scan._getspectrum,-1))
1686	m = array(scan._get_column(scan._getmask,-1))
1687	y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
1688	x = arange(len(y))
1689	# try to handle spectral data somewhat...
1690	l,m = y.shape
1691	if m > 1:
1692	y=y.mean(axis=1)
1693	# flag handling
1694	m = [ scan._is_all_chan_flagged(i) for i in range(scan.nrow()) ]
1695	y = ma.masked_array(y,mask=m)
1696	plotit = self._plotter.plot
1697	llbl = self._get_label(scan, r, self._stacking, None)
1698	self._plotter.set_line(label=llbl)
1699	if len(x) > 0:
1700	plotit(x,y)
1701
1702
1703	# printing header information
1704	@asaplog_post_dec
1705	def print_header(self, plot=True, fontsize=9, logger=False, selstr='', extrastr=''):
1706	"""
1707	print data (scantable) header on the plot and/or logger.
1708	To plot the header on the plot, this method should be called after
1709	plotting spectra by the method, asapplotter.plot.
1710	Parameters:
1711	plot: whether or not print header info on the plot.
1712	fontsize: header font size (valid only plot=True)
1713	logger: whether or not print header info on the logger.
1714	selstr: additional selection string (not verified)
1715	extrastr: additional string to print at the beginning (not verified)
1716	"""
1717	if not plot and not logger:
1718	return
1719	if not self._data:
1720	raise RuntimeError("No scantable has been set yet.")
1721	# Now header will be printed on plot and/or logger.
1722	# Get header information and format it.
1723	ssum=self._data._list_header()
1724	# Print Observation header to the upper-left corner of plot
1725	headstr=[ssum[0:ssum.find('Obs. Type:')]]
1726	headstr.append(ssum[ssum.find('Obs. Type:'):ssum.find('Flux Unit:')])
1727	if extrastr != '':
1728	headstr[0]=extrastr+'\n'+headstr[0]
1729	self._headtext['extrastr'] = extrastr
1730	if selstr != '':
1731	selstr += '\n'
1732	self._headtext['selstr'] = selstr
1733	#ssel=(selstr+self._data.get_selection().__str__()+self._selection.__str__() or 'none')
1734	curr_selstr = selstr+self._data.get_selection().__str__() or "none"
1735	ssel=(curr_selstr+"\n" +self._selection.__str__())
1736	headstr.append('\n\n*Selections*\n'+ssel.replace('$','\$'))
1737
1738	if plot:
1739	errmsg = "Can plot header only after the first call to plot()."
1740	self._assert_plotter(action="halt",errmsg=errmsg)
1741	self._plotter.hold()
1742	self._header_plot(headstr,fontsize=fontsize)
1743	#import time
1744	#self._plotter.figure.text(0.99,0.01,
1745	# time.strftime("%a %d %b %Y %H:%M:%S %Z"),
1746	# horizontalalignment='right',
1747	# verticalalignment='bottom',fontsize=8)
1748	self._plotter.release()
1749	if logger:
1750	selstr = "Selections: "+ssel
1751	asaplog.push("----------------\n Plot Summary\n----------------")
1752	asaplog.push(extrastr)
1753	asaplog.push(ssum[0:ssum.find('Selection:')]\
1754	+ selstr)
1755	self._headtext['string'] = headstr
1756	del ssel, ssum, headstr
1757
1758	def _header_plot(self, texts, fontsize=9):
1759	self._headtext['textobj']=[]
1760	nstcol=len(texts)
1761	for i in range(nstcol):
1762	self._headtext['textobj'].append(
1763	self._plotter.figure.text(0.03+float(i)/nstcol,0.98,
1764	texts[i],
1765	horizontalalignment='left',
1766	verticalalignment='top',
1767	fontsize=fontsize))
1768
1769	def clear_header(self):
1770	if not self._headtext['textobj']:
1771	asaplog.push("No header has been plotted. Exit without any operation")
1772	asaplog.post("WARN")
1773	elif self._assert_plotter(action="status"):
1774	self._plotter.hold()
1775	for textobj in self._headtext['textobj']:
1776	#if textobj.get_text() in self._headstring:
1777	try:
1778	textobj.remove()
1779	except NotImplementedError:
1780	self._plotter.figure.texts.pop(self._plotter.figure.texts.index(textobj))
1781	self._plotter.release()
1782	self._reset_header()
1783
1784	# plot spectra by pointing
1785	@asaplog_post_dec
1786	def plotgrid(self, scan=None,center="",spacing=[],rows=None,cols=None):
1787	"""
1788	Plot spectra based on direction.
1789
1790	Parameters:
1791	scan: a scantable to plot
1792	center: the grid center direction (a string)
1793	(default) the center of map region
1794	(example) 'J2000 19h30m00s -25d00m00s'
1795	spacing: a list of horizontal (R.A.) and vertical (Dec.)
1796	spacing.
1797	(default) Calculated by the extent of map region and
1798	(example) ['1arcmin', '1arcmin']
1799	the number of rows and cols to cover
1800	rows: number of panels (grid points) in horizontal direction
1801	cols: number of panels (grid points) in vertical direction
1802
1803	Note:
1804	- Only the first IFNO, POLNO, and BEAM in the scantable will be
1805	plotted.
1806	- This method doesn't re-grid and average spectra in scantable. Use
1807	asapgrid module to re-grid spectra before plotting with this method.
1808	Only the first spectrum is plotted in case there are multiple
1809	spectra which belong to a grid.
1810	"""
1811	self._plotmode = "grid"
1812	from asap import scantable
1813	from numpy import array, ma, cos
1814	if not self._data and not scan:
1815	msg = "No scantable is specified to plot"
1816	raise TypeError(msg)
1817	if scan:
1818	self.set_data(scan, refresh=False)
1819	del scan
1820
1821	# Rows and cols
1822	if (self._rows is None):
1823	rows = max(1, rows)
1824	if (self._cols is None):
1825	cols = max(1, cols)
1826	self.set_layout(rows,cols,False)
1827
1828	# Select the first IF, POL, and BEAM for plotting
1829	ntotpl = self._rows * self._cols
1830	ifs = self._data.getifnos()
1831	if len(ifs) > 1:
1832	msg = "Found multiple IFs in scantable. Only the first IF (IFNO=%d) will be plotted." % ifs[0]
1833	asaplog.post()
1834	asaplog.push(msg)
1835	asaplog.post("WARN")
1836	pols = self._data.getpolnos()
1837	if len(pols) > 1:
1838	msg = "Found multiple POLs in scantable. Only the first POL (POLNO=%d) will be plotted." % pols[0]
1839	asaplog.post()
1840	asaplog.push(msg)
1841	asaplog.post("WARN")
1842	beams = self._data.getbeamnos()
1843	if len(beams) > 1:
1844	msg = "Found multiple BEAMs in scantable. Only the first BEAM (BEAMNO=%d) will be plotted." % beams[0]
1845	asaplog.post()
1846	asaplog.push(msg)
1847	asaplog.post("WARN")
1848	self._data.set_selection(ifs=[ifs[0]],pols=[pols[0]],beams=[beams[0]])
1849	if self._data.nrow() > ntotpl:
1850	msg = "Scantable is finely sampled than plotting grids. "\
1851	+ "Only the first spectrum is plotted in each grid."
1852	asaplog.post()
1853	asaplog.push(msg)
1854	asaplog.post("WARN")
1855
1856	# Prepare plotter
1857	self._assert_plotter(action="reload")
1858	self._plotter.hold()
1859	self._reset_counter()
1860	self._plotter.legend()
1861
1862	# Adjust subplot margins
1863	if not self._margins or len(self._margins) !=6:
1864	self.set_margin(refresh=False)
1865	self._plotter.set_panels(rows=self._rows,cols=self._cols,
1866	nplots=ntotpl,margin=self._margins,ganged=True)
1867	if self.casabar_exists():
1868	self._plotter.figmgr.casabar.enable_button()
1869	# Plot helper
1870	from asap._asap import plothelper as plhelper
1871	ph = plhelper(self._data)
1872	#ph.set_gridval(self._cols, self._rows, spacing[0], spacing[1],
1873	# center[0], center[1], epoch="J2000", projname="SIN")
1874	if type(spacing) in (list, tuple, array):
1875	if len(spacing) == 0:
1876	spacing = ["", ""]
1877	elif len(spacing) == 1:
1878	spacing = [spacing[0], spacing[0]]
1879	else:
1880	spacing = [spacing, spacing]
1881	ph.set_grid(self._cols, self._rows, spacing[0], spacing[1], \
1882	center, projname="SIN")
1883
1884	# Actual plot
1885	npl = 0
1886	for irow in range(self._data.nrow()):
1887	(ix, iy) = ph.get_gpos(irow)
1888	#print("asapplotter.plotgrid: (ix, iy) = (%f, %f)" % (ix, iy))
1889	if ix < 0 or ix >= self._cols:
1890	#print "Row %d : Out of X-range (x = %f) ... skipped" % (irow, pos[0])
1891	continue
1892	ix = int(ix)
1893	if iy < 0 or iy >= self._rows:
1894	#print "Row %d : Out of Y-range (y = %f) ... skipped" % (irow,pos[1])
1895	continue
1896	iy = int(iy)
1897	ipanel = ix + iy*self._rows
1898	#print("Resolved panel Id (%d, %d): %d" % (ix, iy, ipanel))
1899	if len(self._plotter.subplots[ipanel]['lines']) > 0:
1900	#print "Row %d : panel %d lready plotted ... skipped" % (irow,ipanel)
1901	# a spectrum already plotted in the panel
1902	continue
1903	# Plotting this row
1904	#print "PLOTTING row %d (panel=%d)" % (irow, ipanel)
1905	npl += 1
1906	self._plotter.subplot(ipanel)
1907	self._plotter.palette(0,colormap=self._colormap, \
1908	linestyle=0,linestyles=self._linestyles)
1909	xlab = self._abcissa and self._abcissa[ipanel] \
1910	or self._data._getabcissalabel(irow)
1911	if self._offset and not self._abcissa:
1912	xlab += " (relative)"
1913	ylab = self._ordinate and self._ordinate[ipanel] \
1914	or self._data._get_ordinate_label()
1915	self._plotter.set_axes('xlabel', xlab)
1916	self._plotter.set_axes('ylabel', ylab)
1917	lbl = self._data.get_direction(irow)
1918	self._plotter.set_axes('title',lbl)
1919
1920	y = self._data._getspectrum(irow)
1921	# flag application
1922	mr = self._data._getflagrow(irow)
1923	if mr: # FLAGROW=True
1924	y = ma.masked_array(y,mask=mr)
1925	else:
1926	m = self._data._getmask(irow)
1927	from numpy import logical_not, logical_and
1928	### user mask is not available so far
1929	#if self._maskselection and len(self._usermask) == len(m):
1930	# if d[self._stacking](irow) in self._maskselection[self._stacking]:
1931	# m = logical_and(m, self._usermask)
1932	y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
1933
1934	x = array(self._data._getabcissa(irow))
1935	if self._offset:
1936	x += self._offset
1937	if self._minmaxx is not None:
1938	s,e = self._slice_indeces(x)
1939	x = x[s:e]
1940	y = y[s:e]
1941	if len(x) > 1024 and rcParams['plotter.decimate']:
1942	fac = len(x)/1024
1943	x = x[::fac]
1944	y = y[::fac]
1945	self._plotter.set_line(label=lbl)
1946	plotit = self._plotter.plot
1947	if self._hist: plotit = self._plotter.hist
1948	if len(x) > 0 and not mr:
1949	plotit(x,y)
1950	# xlim= self._minmaxx or [min(x),max(x)]
1951	# allxlim += xlim
1952	# ylim= self._minmaxy or [ma.minimum(y),ma.maximum(y)]
1953	# allylim += ylim
1954	# else:
1955	# xlim = self._minmaxx or []
1956	# allxlim += xlim
1957	# ylim= self._minmaxy or []
1958	# allylim += ylim
1959
1960	if npl >= ntotpl:
1961	break
1962
1963	if self._minmaxy is not None:
1964	self._plotter.set_limits(ylim=self._minmaxy)
1965	self._plotter.release()
1966	self._plotter.tidy()
1967	self._plotter.show(hardrefresh=False)
1968	return

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

Download in other formats: