source: trunk/python/asapplotter.py@ 2696

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

New Development: No

JIRA Issue: Yes (TRAC-287)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): asapplotter and sdplot

Description: bug fixes to asapplotter.plotpoining2


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