Context Navigation

asapplotter.py@ 2604

Visit:

Last change on this file since 2604 was 2604, checked in by Kana Sugimoto, 12 years ago

New Development: No

JIRA Issue: No (minor improvements)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs: unit tests of sdplot

Put in Release Notes: No

Module(s): asapplotter, sdplot (CASA)

Description:

Eliminated duplication of codes.
A minor bug fix to asapplotter.plotgrid.
Initial attempt to add destructor to asapplotter class.

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

File size: 73.7 KB

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

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

Context Navigation

source: trunk/python/asapplotter.py@ 2604

Download in other formats: