source: trunk/python/asapplotter.py @ 2992

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

New Development: No

JIRA Issue: Yes (CAS-6704)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): asapplotter, sdplot

Description: Fixed bugs in asapplotter._plottp_in_time.

Combination of the first IFs/Pols/Beams is selected to plot total power unless it is not used for plot overlay.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 85.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        ### 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            scan    : input 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, colorby=''):
1648        """
1649        Plot averaged spectra (total power) in time or in row ID (colorby='')
1650        Parameters:
1651            scan    : input scantable instance
1652            colorby : change color by either
1653                      'type'(source type)|'scan'|'if'|'pol'|'beam'|''
1654        """
1655        self._plotmode = "totalpower"
1656        from asap import scantable
1657        if not self._data and not scan:
1658            msg = "Input is not a scantable"
1659            raise TypeError(msg)
1660        if isinstance(scan, scantable):
1661            if self._data is not None:
1662                if scan != self._data:
1663                    self._data = scan
1664                    # reset
1665                    self._reset()
1666            else:
1667                self._data = scan
1668                self._reset()
1669        # ranges become invalid when abcissa changes?
1670        #if self._abcunit and self._abcunit != self._data.get_unit():
1671        #    self._minmaxx = None
1672        #    self._minmaxy = None
1673        #    self._abcunit = self._data.get_unit()
1674
1675        self._assert_plotter(action="reload")
1676        self._plotter.hold()
1677        self._plotter.clear()
1678        # Adjust subplot margins
1679        if not self._margins or len(self._margins) !=6:
1680            self.set_margin(refresh=False)
1681        lef, bot, rig, top, wsp, hsp = self._margins
1682        self._plotter.figure.subplots_adjust(
1683            left=lef,bottom=bot,right=rig,top=top,wspace=wsp,hspace=hsp)
1684        if self.casabar_exists(): self._plotter.figmgr.casabar.disable_button()
1685        if len(colorby) == 0:
1686            self._plottp(self._data)
1687        else:
1688            self._plottp_in_time(self._data,colorby)
1689        if self._minmaxy is not None:
1690            self._plotter.set_limits(ylim=self._minmaxy)
1691        self._plotter.release()
1692        self._plotter.tidy()
1693        self._plotter.show(hardrefresh=False)
1694        return
1695
1696    def _plottp_in_time(self,scan,colorby):
1697        """
1698        private method for plotting total power data in time
1699        Parameters:
1700            scan    : input scantable instance
1701            colorby : change color by either
1702                      'type'(source type)|'scan'|'if'|'pol'|'beam'
1703        """
1704        from numpy import ma, array, arange, logical_not
1705        r=0
1706        nr = scan.nrow()
1707        a0,b0 = -1,-1
1708        allxlim = []
1709        allylim = []
1710        y=[]
1711        self._plotter.set_panels()
1712        self._plotter.palette(0)
1713        # check of overlay settings
1714        time_types = ['type','scan'] # time dependent meta-data
1715        misc_types = ['if','pol','beam'] # time independent meta-data
1716        validtypes=time_types + misc_types
1717        stype = None
1718        col_msg = "Invalid choice of 'colorby' (choices: %s)" % str(validtypes)
1719        colorby = colorby.lower()
1720        if (colorby in validtypes):
1721            stype = colorby[0]
1722        elif len(colorby) > 0:
1723            raise ValueError(col_msg)
1724        if not stype:
1725            raise ValueError(col_msg)
1726        # Selection and sort order
1727        basesel = scan.get_selection()
1728        if colorby in misc_types: misc_types.pop(misc_types.index(colorby))
1729        sel_lbl = ""
1730        for meta in misc_types:
1731            idx = getattr(scan,'get'+meta+'nos')()
1732            if len(idx) > 1: getattr(basesel, 'set_'+meta+'s')([idx[0]])
1733            sel_lbl += ("%s%d, " % (meta.upper(), idx[0]))
1734        sel_lbl = sel_lbl.rstrip(', ')
1735        scan.set_selection(basesel)
1736        if len(sel_lbl) > 0:
1737            asaplog.push("Selection contains multiple IFs/Pols/Beams. Plotting the first ones: %s" % sel_lbl)
1738            asaplog.post("WARN")
1739        if stype == 't':
1740            selIds = range(15)
1741            sellab = "src type "
1742        else:
1743            selIds = getattr(scan,'get'+colorby+'nos')()
1744            sellab = colorby.upper()
1745        selFunc = "set_"+colorby+"s"
1746        basesel.set_order(["TIME"])
1747        # define axes labels
1748        xlab = self._abcissa or 'Time (UTC)'
1749        ylab = self._ordinate or scan._get_ordinate_label()
1750        self._plotter.set_axes('xlabel',xlab)
1751        self._plotter.set_axes('ylabel',ylab)
1752        # define the panel title
1753        if len(sel_lbl) > 0: lbl = sel_lbl
1754        else: lbl = self._get_label(scan, r, 's', self._title)
1755        if isinstance(lbl, list) or isinstance(lbl, tuple):
1756            # get default label
1757            lbl = self._get_label(scan, r, self._panelling, None)
1758        self._plotter.set_axes('title',lbl)
1759        # linestyle
1760        lstyle = '' if colorby in time_types else ':'
1761        alldates = []
1762        for idx in selIds:
1763            sel = selector() + basesel
1764            bid = getattr(basesel,'get_'+colorby+"s")()
1765            if (len(bid) > 0) and (not idx in bid):
1766                # base selection doesn't contain idx
1767                # Note summation of selector is logical sum if
1768                continue
1769            getattr(sel, selFunc)([idx])
1770            if not sel.is_empty():
1771                try:
1772                    scan.set_selection(sel)
1773                except RuntimeError, instance:
1774                    if stype == 't' and str(instance).startswith("Selection contains no data."):
1775                        continue
1776                    else:
1777                        scan.set_selection(basesel)
1778                        raise RuntimeError, instance
1779            if scan.nrow() == 0:
1780                scan.set_selection(basesel)
1781                continue
1782            y=array(scan._get_column(scan._getspectrum,-1))
1783            m = array(scan._get_column(scan._getmask,-1))
1784            y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
1785            # try to handle spectral data somewhat...
1786            try:
1787                l,m = y.shape
1788            except ValueError, e:
1789                raise ValueError(str(e)+" This error usually occurs when you select multiple spws with different number of channels. Try selecting single spw and retry.")
1790            if m > 1:
1791                y=y.mean(axis=1)
1792            # flag handling
1793            m = [ scan._is_all_chan_flagged(i) for i in range(scan.nrow()) ]
1794            y = ma.masked_array(y,mask=m)
1795            if len(y) == 0: continue
1796            # line label
1797            llbl=sellab+str(idx)
1798            from matplotlib.dates import date2num
1799            from pytz import timezone
1800            dates = self._data.get_time(asdatetime=True)
1801            alldates += list(dates)
1802            x = date2num(dates)
1803            tz = timezone('UTC')
1804            # get color
1805            lc = self._plotter.colormap[self._plotter.color]
1806            self._plotter.palette( (self._plotter.color+1) % len(self._plotter.colormap) )
1807            # actual plotting
1808            self._plotter.axes.plot_date(x,y,tz=tz,label=llbl,linestyle=lstyle,color=lc,
1809                                         marker='o',markersize=3,markeredgewidth=0)
1810
1811        # legend and axis formatting
1812        (dstr, timefmt, majloc, minloc) = self._get_date_axis_setup(alldates)
1813        ax = self.gca()
1814        ax.xaxis.set_major_formatter(timefmt)
1815        ax.xaxis.set_major_locator(majloc)
1816        ax.xaxis.set_minor_locator(minloc)
1817        self._plotter.axes.legend(loc=self._legendloc)
1818
1819    def _plottp(self,scan):
1820        """
1821        private method for plotting total power data
1822        """
1823        from numpy import ma, array, arange, logical_not
1824        r=0
1825        nr = scan.nrow()
1826        a0,b0 = -1,-1
1827        allxlim = []
1828        allylim = []
1829        y=[]
1830        self._plotter.set_panels()
1831        self._plotter.palette(0)
1832        #title
1833        #xlab = self._abcissa and self._abcissa[panelcount] \
1834        #       or scan._getabcissalabel()
1835        #ylab = self._ordinate and self._ordinate[panelcount] \
1836        #       or scan._get_ordinate_label()
1837        xlab = self._abcissa or 'row number' #or Time
1838        ylab = self._ordinate or scan._get_ordinate_label()
1839        self._plotter.set_axes('xlabel',xlab)
1840        self._plotter.set_axes('ylabel',ylab)
1841        lbl = self._get_label(scan, r, 's', self._title)
1842        if isinstance(lbl, list) or isinstance(lbl, tuple):
1843        #    if 0 <= panelcount < len(lbl):
1844        #        lbl = lbl[panelcount]
1845        #    else:
1846                # get default label
1847             lbl = self._get_label(scan, r, self._panelling, None)
1848        self._plotter.set_axes('title',lbl)
1849        y=array(scan._get_column(scan._getspectrum,-1))
1850        m = array(scan._get_column(scan._getmask,-1))
1851        y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
1852        x = arange(len(y))
1853        # try to handle spectral data somewhat...
1854        try:
1855            l,m = y.shape
1856        except ValueError, e:
1857                raise ValueError(str(e)+" This error usually occurs when you select multiple spws with different number of channels. Try selecting single spw and retry.")
1858        if m > 1:
1859            y=y.mean(axis=1)
1860        # flag handling
1861        m = [ scan._is_all_chan_flagged(i) for i in range(scan.nrow()) ]
1862        y = ma.masked_array(y,mask=m)
1863        plotit = self._plotter.plot
1864        llbl = self._get_label(scan, r, self._stacking, None)
1865        self._plotter.set_line(label=llbl)
1866        if len(x) > 0:
1867            plotit(x,y)
1868
1869
1870    # printing header information
1871    @asaplog_post_dec
1872    def print_header(self, plot=True, fontsize=9, logger=False, selstr='', extrastr=''):
1873        """
1874        print data (scantable) header on the plot and/or logger.
1875        To plot the header on the plot, this method should be called after
1876        plotting spectra by the method, asapplotter.plot.
1877        Parameters:
1878            plot:      whether or not print header info on the plot.
1879            fontsize:  header font size (valid only plot=True)
1880            logger:    whether or not print header info on the logger.
1881            selstr:    additional selection string (not verified)
1882            extrastr:  additional string to print at the beginning (not verified)
1883        """
1884        if not plot and not logger:
1885            return
1886        if not self._data:
1887            raise RuntimeError("No scantable has been set yet.")
1888        # Now header will be printed on plot and/or logger.
1889        # Get header information and format it.
1890        ssum=self._data._list_header()
1891        # Print Observation header to the upper-left corner of plot
1892        headstr=[ssum[0:ssum.find('Obs. Type:')]]
1893        headstr.append(ssum[ssum.find('Obs. Type:'):ssum.find('Flux Unit:')])
1894        if extrastr != '':
1895            headstr[0]=extrastr+'\n'+headstr[0]
1896            self._headtext['extrastr'] = extrastr
1897        if selstr != '':
1898            selstr += '\n'
1899            self._headtext['selstr'] = selstr
1900        #ssel=(selstr+self._data.get_selection().__str__()+self._selection.__str__() or 'none')
1901        curr_selstr = selstr+self._data.get_selection().__str__() or "none"
1902        ssel=(curr_selstr+"\n" +self._selection.__str__())
1903        headstr.append('\n\n***Selections***\n'+ssel.replace('$','\$'))
1904
1905        if plot:
1906            errmsg = "Can plot header only after the first call to plot()."
1907            self._assert_plotter(action="halt",errmsg=errmsg)
1908            self._plotter.hold()
1909            self._header_plot(headstr,fontsize=fontsize)
1910            #import time
1911            #self._plotter.figure.text(0.99,0.01,
1912            #                time.strftime("%a %d %b %Y  %H:%M:%S %Z"),
1913            #                horizontalalignment='right',
1914            #                verticalalignment='bottom',fontsize=8)
1915            self._plotter.release()
1916        if logger:
1917            selstr = "Selections:    "+ssel
1918            asaplog.push("----------------\n  Plot Summary\n----------------")
1919            asaplog.push(extrastr)
1920            asaplog.push(ssum[0:ssum.find('Selection:')]\
1921                         + selstr)
1922        self._headtext['string'] = headstr
1923        del ssel, ssum, headstr
1924
1925    def _header_plot(self, texts, fontsize=9):
1926        self._headtext['textobj']=[]
1927        nstcol=len(texts)
1928        for i in range(nstcol):
1929            self._headtext['textobj'].append(
1930                self._plotter.figure.text(0.03+float(i)/nstcol,0.98,
1931                                          texts[i],
1932                                          horizontalalignment='left',
1933                                          verticalalignment='top',
1934                                          fontsize=fontsize))
1935
1936    def clear_header(self):
1937        if not self._headtext['textobj']:
1938            asaplog.push("No header has been plotted. Exit without any operation")
1939            asaplog.post("WARN")
1940        elif self._assert_plotter(action="status"):
1941            self._plotter.hold()
1942            for textobj in self._headtext['textobj']:
1943                #if textobj.get_text() in self._headstring:
1944                try:
1945                    textobj.remove()
1946                except NotImplementedError:
1947                    self._plotter.figure.texts.pop(self._plotter.figure.texts.index(textobj))
1948            self._plotter.release()
1949        self._reset_header()
1950
1951    # plot spectra by pointing
1952    @asaplog_post_dec
1953    def plotgrid(self, scan=None,center="",spacing=[],rows=None,cols=None):
1954        """
1955        Plot spectra based on direction.
1956       
1957        Parameters:
1958            scan:      a scantable to plot
1959            center:    the grid center direction (a string)
1960                       (default) the center of map region
1961                       (example) 'J2000 19h30m00s -25d00m00s'
1962            spacing:   a list of horizontal (R.A.) and vertical (Dec.)
1963                       spacing.
1964                       (default) Calculated by the extent of map region and
1965                       (example) ['1arcmin', '1arcmin']
1966                       the number of rows and cols to cover
1967            rows:      number of panels (grid points) in horizontal direction
1968            cols:      number of panels (grid points) in vertical direction
1969
1970        Note:
1971        - Only the first IFNO, POLNO, and BEAM in the scantable will be
1972        plotted.
1973        - This method doesn't re-grid and average spectra in scantable. Use
1974        asapgrid module to re-grid spectra before plotting with this method.
1975        Only the first spectrum is plotted in case there are multiple
1976        spectra which belong to a grid.
1977        """
1978        self._plotmode = "grid"
1979        from asap import scantable
1980        from numpy import array, ma, cos
1981        if not self._data and not scan:
1982            msg = "No scantable is specified to plot"
1983            raise TypeError(msg)
1984        if scan:
1985            self.set_data(scan, refresh=False)
1986            del scan
1987
1988        # Rows and cols
1989        if (self._rows is None):
1990            rows = max(1, rows)
1991        if (self._cols is None):
1992            cols = max(1, cols)
1993        self.set_layout(rows,cols,False)
1994
1995        # Select the first IF, POL, and BEAM for plotting
1996        ntotpl = self._rows * self._cols
1997        ifs = self._data.getifnos()
1998        if len(ifs) > 1:
1999            msg = "Found multiple IFs in scantable. Only the first IF (IFNO=%d) will be plotted." % ifs[0]
2000            asaplog.post()
2001            asaplog.push(msg)
2002            asaplog.post("WARN")
2003        pols = self._data.getpolnos()
2004        if len(pols) > 1:
2005            msg = "Found multiple POLs in scantable. Only the first POL (POLNO=%d) will be plotted." % pols[0]
2006            asaplog.post()
2007            asaplog.push(msg)
2008            asaplog.post("WARN")
2009        beams = self._data.getbeamnos()
2010        if len(beams) > 1:
2011            msg = "Found multiple BEAMs in scantable. Only the first BEAM (BEAMNO=%d) will be plotted." % beams[0]
2012            asaplog.post()
2013            asaplog.push(msg)
2014            asaplog.post("WARN")
2015        self._data.set_selection(ifs=[ifs[0]],pols=[pols[0]],beams=[beams[0]])
2016        if self._data.nrow() > ntotpl:
2017            msg = "Scantable is finely sampled than plotting grids. "\
2018                  + "Only the first spectrum is plotted in each grid."
2019            asaplog.post()
2020            asaplog.push(msg)
2021            asaplog.post("WARN")
2022
2023        # Prepare plotter
2024        self._assert_plotter(action="reload")
2025        self._plotter.hold()
2026        self._reset_counter()
2027        self._plotter.legend()
2028
2029        # Adjust subplot margins
2030        if not self._margins or len(self._margins) !=6:
2031            self.set_margin(refresh=False)
2032        self._plotter.set_panels(rows=self._rows,cols=self._cols,
2033                                 nplots=ntotpl,margin=self._margins,ganged=True)       
2034        if self.casabar_exists():
2035            self._plotter.figmgr.casabar.enable_button()
2036        # Plot helper
2037        from asap._asap import plothelper as plhelper
2038        ph = plhelper(self._data)
2039        #ph.set_gridval(self._cols, self._rows, spacing[0], spacing[1],
2040        #                  center[0], center[1], epoch="J2000", projname="SIN")
2041        if type(spacing) in (list, tuple, array):
2042            if len(spacing) == 0:
2043                spacing = ["", ""]
2044            elif len(spacing) == 1:
2045                spacing = [spacing[0], spacing[0]]
2046        else:
2047            spacing = [spacing, spacing]
2048        ph.set_grid(self._cols, self._rows, spacing[0], spacing[1], \
2049                    center, projname="SIN")
2050
2051        # Actual plot
2052        npl = 0
2053        for irow in range(self._data.nrow()):
2054            (ix, iy) = ph.get_gpos(irow)
2055            #print("asapplotter.plotgrid: (ix, iy) = (%f, %f)" % (ix, iy))
2056            if ix < 0 or ix >= self._cols:
2057                #print "Row %d : Out of X-range (x = %f) ... skipped" % (irow, pos[0])
2058                continue
2059            ix = int(ix)
2060            if iy < 0 or iy >= self._rows:
2061                #print "Row %d : Out of Y-range (y = %f) ... skipped" % (irow,pos[1])
2062                continue
2063            iy = int(iy)
2064            ipanel = ix + iy*self._rows
2065            #print("Resolved panel Id (%d, %d): %d" % (ix, iy, ipanel))
2066            if len(self._plotter.subplots[ipanel]['lines']) > 0:
2067                #print "Row %d : panel %d lready plotted ... skipped" % (irow,ipanel)
2068                # a spectrum already plotted in the panel
2069                continue
2070            # Plotting this row
2071            #print "PLOTTING row %d (panel=%d)" % (irow, ipanel)
2072            npl += 1
2073            self._plotter.subplot(ipanel)
2074            self._plotter.palette(0,colormap=self._colormap, \
2075                                  linestyle=0,linestyles=self._linestyles)
2076            xlab = self._abcissa and self._abcissa[ipanel] \
2077                   or self._data._getabcissalabel(irow)
2078            if self._offset and not self._abcissa:
2079                xlab += " (relative)"
2080            ylab = self._ordinate and self._ordinate[ipanel] \
2081                   or self._data._get_ordinate_label()
2082            self._plotter.set_axes('xlabel', xlab)
2083            self._plotter.set_axes('ylabel', ylab)
2084            lbl = self._data.get_direction(irow)
2085            self._plotter.set_axes('title',lbl)
2086
2087            y = self._data._getspectrum(irow)
2088            # flag application
2089            mr = self._data._getflagrow(irow)
2090            if mr:  # FLAGROW=True
2091                y = ma.masked_array(y,mask=mr)
2092            else:
2093                m = self._data._getmask(irow)
2094                from numpy import logical_not, logical_and
2095                ### user mask is not available so far
2096                #if self._maskselection and len(self._usermask) == len(m):
2097                #    if d[self._stacking](irow) in self._maskselection[self._stacking]:
2098                #            m = logical_and(m, self._usermask)
2099                y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
2100
2101            x = array(self._data._getabcissa(irow))
2102            if self._offset:
2103                x += self._offset
2104            if self._minmaxx is not None:
2105                s,e = self._slice_indeces(x)
2106                x = x[s:e]
2107                y = y[s:e]
2108            if len(x) > 1024 and rcParams['plotter.decimate']:
2109                fac = len(x)/1024
2110                x = x[::fac]
2111                y = y[::fac]
2112            self._plotter.set_line(label=lbl)
2113            plotit = self._plotter.plot
2114            if self._hist: plotit = self._plotter.hist
2115            if len(x) > 0 and not mr:
2116                plotit(x,y)
2117#                 xlim= self._minmaxx or [min(x),max(x)]
2118#                 allxlim += xlim
2119#                 ylim= self._minmaxy or [ma.minimum(y),ma.maximum(y)]
2120#                 allylim += ylim
2121#             else:
2122#                 xlim = self._minmaxx or []
2123#                 allxlim += xlim
2124#                 ylim= self._minmaxy or []
2125#                 allylim += ylim
2126           
2127            if npl >= ntotpl:
2128                break
2129           
2130        if self._minmaxy is not None:
2131            self._plotter.set_limits(ylim=self._minmaxy)
2132        self._plotter.release()
2133        self._plotter.tidy()
2134        self._plotter.show(hardrefresh=False)
2135        return
Note: See TracBrowser for help on using the repository browser.