source: trunk/python/asapplotter.py@ 2989

Last change on this file since 2989 was 2989, checked in by Kana Sugimoto, 11 years ago

New Development: No

JIRA Issue: Yes (related to CAS-6704)

Ready for Test: Yes

Interface Changes: No

What Interface Changes:

Test Programs: plot pointing for a single raster row.

Put in Release Notes: No

Module(s): asapplotter, sdplot

Description: An improvement to asapplotter.plotpointing2. Expand plot ranges in case of single pointing or single raster row is selected.


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