Changeset 2605 for trunk/python

Timestamp:

07/20/12 17:49:33 (12 years ago)

Author:

Kana Sugimoto

Message:

New Development: Yes

JIRA Issue: Yes (CAS-3616/Trac-274)

Ready for Test: Yes

Interface Changes: Yes

What Interface Changed: a new method flagplotter._plot_with_flag()

and flagplotter.set_showflag().

Test Programs:

Put in Release Notes: No

Module(s): flagplotter, sdflag

Description:

The initial attempt to enable plotting flagged data in interactive flagging.
flagplotter module now uses their own plotting method, _plot_with_flag(),
to plot flagged data.
Also a minor fix to legend position in custom toolbar.

Location:

trunk/python

Files:

• customgui_base.py (modified) (1 diff)
• flagplotter.py (modified) (6 diffs)

trunk/python/customgui_base.py

@@ -1167 +1167 @@
 
         self.plotter._plotter.hold()
-        self.plotter._plotter.legend(1)
+        #self.plotter._plotter.legend(1)
         self._set_plot_counter(pagemode)
         self.plotter._plot(self.plotter._data)

trunk/python/flagplotter.py

@@ -32 +32 @@
         self.set_stacking('scan')
         self._ismodified = False
+        self._showflag = True #False
+        self.set_colors("blue gray",False)
 
     def _new_custombar(self):
@@ -49 +51 @@
             asaplog.post("ERROR")
 
+    def set_showflag(self, show):
+        """ Whether or not plotting flagged data"""
+        if type(show) == bool:
+            self._showflag = show
+
     @asaplog_post_dec
     def _invalid_func(self, name):
@@ -61 +68 @@
             return
         msg = "Pannel setting is fixed to row mode in 'flagplotter'"
+        asaplog.push(msg)
+        asaplog.post('ERROR')
+        self._panelling = 'r'
+
+    def set_range(self,xstart=None,xend=None,ystart=None,yend=None,refresh=False, offset=None):
+        """ This function is not available for the class flagplotter """
+        msg = "Plot range setting is not allowed in 'flagplotter'"
         asaplog.push(msg)
         asaplog.post('ERROR')
@@ -116 +130 @@
         if self._is_new_scan(scan):
             self._ismodified = False
+        if not self._showflag:
+            self.set_legend(mode=None,refresh=False)
+        elif not self._legendloc:
+            self.set_legend(mode=1,refresh=False)
         asapplotter.plot(self,scan)
     plot.__doc__ = asapplotter.plot.__doc__
@@ -121 +139 @@
     @asaplog_post_dec
     def _plot(self, scan):
-        asapplotter._plot(self,scan)
+        self._plot_with_flag(scan,self._showflag)
         # rescale x-range of subplots 5% margins
         ganged = (self._plotter.axes._sharex != None)
@@ -136 +154 @@
     _plot.__doc__ = asapplotter._plot.__doc__
 
+
+    @asaplog_post_dec
+    def _plot_with_flag(self, scan, showflag=True):
+        # total number of panles to plot as a whole
+        nptot = scan.nrow()
+        # remaining panels to plot
+        n = nptot - self._ipanel - 1
+        ganged = False
+        maxpanel = 25
+
+        if n > 1:
+            ganged = rcParams['plotter.ganged']
+            if self._rows and self._cols:
+                n = min(n,self._rows*self._cols)
+                self._plotter.set_panels(rows=self._rows,cols=self._cols,
+                                         nplots=n,margin=self._margins,ganged=ganged)
+            else:
+                n = min(n,maxpanel)
+                self._plotter.set_panels(rows=n,cols=0,nplots=n,margin=self._margins,ganged=ganged)
+        else:
+            self._plotter.set_panels(margin=self._margins)
+        #r = 0
+        r = self._startrow
+        # total row number of scantable
+        nr = scan.nrow()
+        panelcount = 0
+
+        while r < nr:
+            # always plot to new panel
+            self._plotter.subplot(panelcount)
+            self._plotter.palette(0)
+            # title and axes labels
+            xlab = self._abcissa and self._abcissa[panelcount] \
+                       or scan._getabcissalabel()
+            if self._offset and not self._abcissa:
+                xlab += " (relative)"
+            ylab = self._ordinate and self._ordinate[panelcount] \
+                   or scan._get_ordinate_label()
+            self._plotter.set_axes('xlabel', xlab)
+            self._plotter.set_axes('ylabel', ylab)
+            lbl = self._get_label(scan, r, mode='title', userlabel=self._title)
+            if type(lbl) in (list, tuple):
+                if 0 <= panelcount < len(lbl):
+                    lbl = lbl[panelcount]
+                else:
+                    # get default label
+                    lbl = self._get_label(scan, r, 'title')
+            self._plotter.set_axes('title',lbl)
+            panelcount += 1
+            # Now get data to plot
+            y = scan._getspectrum(r)
+            #flag row
+            mr = scan._getflagrow(r)
+            from numpy import ma, array
+            if mr:
+                ys = ma.masked_array(y,mask=mr)
+                if showflag:
+                    yf = ma.masked_array(y, mask=(not mr))
+            else:
+                m = scan._getmask(r)
+                from numpy import logical_not, logical_and
+                if self._maskselection and len(self._usermask) == len(m):
+                    if d[self._stacking](r) in self._maskselection[self._stacking]:
+                        m = logical_and(m, self._usermask)
+                ys = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
+                if showflag:
+                    yf = ma.masked_array(y,mask=m)
+
+            x = array(scan._getabcissa(r))
+            if self._offset:
+                x += self._offset
+            llbl = self._get_label(scan, r, mode='legend', userlabel=self._lmap)
+            if type(llbl) in (list, tuple):
+                        llbl = llbl[0]
+            self._plotter.set_line(label=llbl)
+            plotit = self._plotter.plot
+            if self._hist: plotit = self._plotter.hist
+            plotit(x,ys)
+            if showflag:
+                self._plotter.set_line(label="flagged")
+                plotit(x,yf)
+            if (panelcount == n) or (r == nr-1):
+                break
+            r+=1 # next row
+        
+
+        # save the current counter for multi-page plotting
+        self._startrow = r+1
+        self._ipanel += panelcount
+        if self.casabar_exists():
+            if self._ipanel >= nptot-1:
+                self._plotter.figmgr.casabar.disable_next()
+            else:
+                self._plotter.figmgr.casabar.enable_next()
+            if self._ipanel + 1 - panelcount > 0:
+                self._plotter.figmgr.casabar.enable_prev()
+            else:
+                self._plotter.figmgr.casabar.disable_prev()
+
+                
+
+    def _get_label(self, scan, row, mode='title', userlabel=None):
+        if isinstance(userlabel, list) and len(userlabel) == 0:
+            userlabel = " "
+        elif not mode.upper().startswith('T'):
+            pms = dict(zip(self._selection.get_pols(), \
+                           self._selection.get_poltypes()))
+            if len(pms):
+                poleval = scan._getpollabel(scan.getpol(row), \
+                                            pms[scan.getpol(row)])
+            else:
+                poleval = scan._getpollabel(scan.getpol(row),scan.poltype())
+            label = "IF%d, POL %s, Scan%d" % \
+                    (scan.getif(row),poleval,scan.getscan(row))
+        else:
+            label = "row %d" % (row)
+            
+        return userlabel or label
+        
+
     def _is_new_scan(self,scan):
         if isinstance(scan, scantable):