Changeset 709 for trunk/python


Ignore:
Timestamp:
11/02/05 13:26:04 (19 years ago)
Author:
mar637
Message:

changes to reflect change in asaplot

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/python/asapplotter.py

    r702 r709  
    1 from asap.asaplot import ASAPlot
    21from asap import rcParams
     2from numarray import logical_and
    33
    44class asapplotter:
    … …  
    1111        other variables.
    1212    """
    13     def __init__(self):
    14         self._plotter = ASAPlot()
    15 
     13    def __init__(self, visible=True):
     14       
     15        if visible:
     16            from asap.asaplotgui import asaplotgui as asaplot
     17        else:
     18            from asap.asaplot import asaplot
     19        self._plotter = asaplot()
     20           
    1621        self._tdict = {'Time':'t','time':'t','t':'t','T':'t'}
    1722        self._bdict = {'Beam':'b','beam':'b','b':'b','B':'b'}
    … …  
    4045        self._minmaxx = None
    4146        self._minmaxy = None
     47        self._datamask = None
    4248        self._data = None
    4349        self._lmap = None
    … …  
    4551        self._ordinate = None
    4652        self._abcissa = None
     53        self._abcunit = None
    4754        self._cursor = {'t':None, 'b':None,
    4855                        'i':None, 'p':None
    … …  
    5461                return d[name]
    5562        return None
    56        
     63
    5764    def plot(self, *args):
    5865        """
    5966        Plot a (list of) scantables.
    6067        Parameters:
    61             one or more comma separated scantables 
     68            one or more comma separated scantables
    6269        Note:
    6370            If a (list) of scantables was specified in a previous call
    … …  
    6673            are consistent e.g. all 'channel' or all 'velocity' etc.
    6774        """
    68         if self._plotter.is_dead:
     75        if self._plotter.is_dead:
    6976            self._plotter = ASAPlot()
    7077        self._plotter.hold()
    7178        self._plotter.clear()
    7279        if len(args) > 0:
    73             if self._data is not None:               
     80            if self._data is not None:
    7481                if list(args) != self._data:
    7582                    self._data = list(args)
    … …  
    7986                self._data = list(args)
    8087                self.set_cursor(refresh=False)
     88        # ranges become invalid when unit changes
     89        if self._abcunit != self._data[0].get_unit():
     90            self._minmaxx = None
     91            self._minmaxy = None
     92            self._abcunit = self._data[0].get_unit()
     93            self._datamask = None
    8194        if self._panelling == 't':
    8295            maxrows = 25
    … …  
    93106        else:
    94107            self._plot_other(self._data, self._stacking)
    95         if self._minmaxx is not None or self._minmaxy is not None:
    96             self._plotter.set_limits(xlim=self._minmaxx,ylim=self._minmaxy)
     108        if self._minmaxy is not None:
     109            self._plotter.set_limits(ylim=self._minmaxy)
    97110        self._plotter.release()
    98111        return
    … …  
    133146                savej = j
    134147                for k in cdict.keys():
    135                     sel = eval(cdict2.get(k))                   
     148                    sel = eval(cdict2.get(k))
    136149                    j = sel[0]
    137150                    if k == "p":
    … …  
    143156                if colmode == "p":
    144157                    polmode = self._polmode[self._cursor["p"].index(j)]
    145                     j = jj
     158                    #j = jj
    146159                eval(cdict.get(colmode))
    147160                x = None
    … …  
    149162                m = None
    150163                if self._title is None:
    151                     tlab = scan._getsourcename(rowsel)                   
     164                    tlab = scan._getsourcename(rowsel)
    152165                else:
    153166                    if len(self._title) >= n:
    … …  
    171184                    ylab = scan._get_ordinate_label()
    172185                m = scan._getmask(rowsel)
     186                if self._datamask is not None:
     187                    if len(m) == len(self._datamask):
     188                        m = logical_and(m,self._datamask)
    173189                if self._lmap and len(self._lmap) > 0:
    174190                    llab = self._lmap[jj]
    … …  
    176192                    if colmode == 'p':
    177193                        llab = self._get_pollabel(scan, polmode)
    178                     else:                   
     194                    else:
    179195                        llab = self._ldict.get(colmode)+' '+str(j)
    180196                self._plotter.set_line(label=llab)
     197                if self._minmaxx is not None:
     198                    s,e = self._slice_indeces(x)
     199                    x = x[s:e]
     200                    y = y[s:e]
     201                    m = m[s:e]
    181202                self._plotter.plot(x,y,m)
    182203                xlim=[min(x),max(x)]
    183                 self._plotter.axes.set_xlim(xlim)
     204                if self._minmaxx is not None:
     205                    xlim = self._minmaxx
     206                self._plotter.axes.set_xlim(xlim)
    184207            self._plotter.set_axes('xlabel',xlab)
    185208            self._plotter.set_axes('ylabel',ylab)
    186             self._plotter.set_axes('title',tlab)           
     209            self._plotter.set_axes('title',tlab)
    187210        return
    188211
    … …  
    197220                  'i':'self._cursor["i"]',
    198221                  'p':'self._cursor["p"]'}
    199        
     222
    200223        n = len(scans)
    201224        ncol = 1
    … …  
    212235        else:
    213236            self._plotter.set_panels()
     237
    214238        for scan in scans:
    215239            self._plotter.palette(0)
    … …  
    223247                savej = j
    224248                for k in cdict.keys():
    225                     sel = eval(cdict2.get(k))                   
     249                    sel = eval(cdict2.get(k))
    226250                    j = sel[0]
    227251                    eval(cdict.get(k))
    … …  
    233257                if colmode == "p":
    234258                    polmode = self._polmode[self._cursor["p"].index(j)]
    235                     j = jj
     259                    #j = jj
    236260                eval(cdict.get(colmode))
    237261                x = None
    … …  
    256280                    ylab = scan._get_ordinate_label()
    257281                m = scan._getmask(rowsel)
     282                if self._datamask is not None:
     283                    if len(m) == len(self._datamask):
     284                        m = logical_and(m,self._datamask)
    258285                if self._lmap and len(self._lmap) > 0:
    259286                    llab = self._lmap[jj]
    … …  
    264291                        llab = self._ldict.get(colmode)+' '+str(j)
    265292                self._plotter.set_line(label=llab)
     293                if self._minmaxx is not None:
     294                    s,e = self._slice_indeces(x)
     295                    x = x[s:e]
     296                    y = y[s:e]
     297                    m = m[s:e]
     298
    266299                self._plotter.plot(x,y,m)
    267300                xlim=[min(x),max(x)]
     301                if self._minmaxx is not None:
     302                    xlim = self._minmaxx
    268303                self._plotter.axes.set_xlim(xlim)
    269304
    … …  
    272307            self._plotter.set_axes('title',tlab)
    273308        return
    274    
     309
    275310    def _plot_other(self,scans,colmode):
    276311        if colmode == self._panelling:
    … …  
    287322        n = eval(self._cdict.get(self._panelling))
    288323        ncol=1
    289         if self._stacking is not None:           
     324        if self._stacking is not None:
    290325            ncol = eval(self._cdict.get(colmode))
    291326        if n > 1:
    … …  
    297332                self._plotter.set_panels(rows=n,cols=0,nplots=n)
    298333        else:
    299             self._plotter.set_panels()           
    300         panels = self._cursor[self._panelling]       
     334            self._plotter.set_panels()
     335        panels = self._cursor[self._panelling]
    301336        for i in panels:
    302337            self._plotter.palette(0)
    … …  
    322357                            which = self._cursor["p"].index(i)
    323358                            polmode = self._polmode[which]
    324                             i = which                       
     359                            i = which
    325360                        eval(cdict.get(k))
    326361                i = savei
    … …  
    328363                    scan = j
    329364                elif colmode == 't':
    330                     rowsel = j                   
     365                    rowsel = j
    331366                else:
    332367                    savei = i
    … …  
    355390                    ylab = scan._get_ordinate_label()
    356391                m = scan._getmask(rowsel)
     392                if self._datamask is not None:
     393                    if len(m) == len(self._datamask):
     394                        m = logical_and(m,self._datamask)
    357395                if colmode == 's' or colmode == 't':
    358396                    if self._title and len(self._title) > 0:
    359397                        tlab = self._title[ii]
    360                     else:                       
    361                         tlab = self._ldict.get(self._panelling)+' '+str(i)
     398                    else:
     399                        if self._panelling == 'p':
     400                            tlab = self._get_pollabel(scan, polmode)
     401                        else:
     402                            tlab = self._ldict.get(self._panelling)+' '+str(i)
    362403                    if self._lmap and len(self._lmap) > 0:
    363404                        llab = self._lmap[jj]
    … …  
    380421                            llab = self._ldict.get(colmode)+' '+str(j)
    381422                self._plotter.set_line(label=llab)
     423                if self._minmaxx is not None:
     424                    s,e = self._slice_indeces(x)
     425                    x = x[s:e]
     426                    y = y[s:e]
     427                    m = m[s:e]
     428
    382429                self._plotter.plot(x,y,m)
    383430                xlim=[min(x),max(x)]
     431                if self._minmaxx is not None:
     432                    xlim = self._minmaxx
    384433                self._plotter.axes.set_xlim(xlim)
    385434
    … …  
    387436            self._plotter.set_axes('ylabel',ylab)
    388437            self._plotter.set_axes('title',tlab)
    389        
     438
    390439        return
    391440
    … …  
    443492        return
    444493
    445     def set_stacking(self, what=None): 
     494    def set_stacking(self, what=None):
    446495        mode = what
    447         if mode is None:           
    448              mode = rcParams['plotter.stacking']       
     496        if mode is None:
     497             mode = rcParams['plotter.stacking']
    449498        md = self._translate(mode)
    450499        if md:
    … …  
    471520            self._minmaxy = None
    472521        else:
    473             self._minmaxy = [ystart,yend]           
     522            self._minmaxy = [ystart,yend]
    474523        if self._data: self.plot()
    475524        return
    476    
     525
    477526    def set_legend(self, mp=None):
    478527        """
    … …  
    510559        return
    511560
    512     def save(self, filename=None, orientation='landscape'):
     561    def save(self, filename=None, orientation=None,dpi=None):
    513562        """
    514563        Save the plot to a file. The know formats are 'png', 'ps', 'eps'.
    … …  
    519568                          called 'yyyymmdd_hhmmss.png' is created in the
    520569                          current directory.
    521              orientation: optional parameter for postscript. 'landscape'
    522                           (default) and 'portrait' are valid.
    523         """
    524         self._plotter.save(filename,orientation)
    525         return
    526    
     570             orientation: optional parameter for postscript only (not eps).
     571                          'landscape', 'portrait' or None (default) are valid.
     572                          If None is choosen for 'ps' output, the plot is
     573                          automatically oriented to fill the page.
     574        """
     575        self._plotter.save(filename,orientation,dpi)
     576        return
     577
    527578    def set_cursor(self, row=None,beam=None,IF=None,pol=None, refresh=True):
    528579        """
    … …  
    549600
    550601        Note:
    551             Be careful to select only exisiting polarisations.           
     602            Be careful to select only exisiting polarisations.
    552603        """
    553604        if not self._data:
    554605            print "Can only set cursor after a first call to plot()"
    555606            return
    556        
     607
    557608        n = self._data[0].nrow()
    558609        if row is None:
    … …  
    572623                if i < 0 or  i >= n:
    573624                    print "Beam index '%d' out of range" % i
    574                     return           
     625                    return
    575626            self._cursor["b"] = beam
    576627
    … …  
    582633                if i < 0 or i >= n:
    583634                    print "IF index '%d' out of range" %i
    584                     return           
    585             self._cursor["i"] = IF           
     635                    return
     636            self._cursor["i"] = IF
    586637
    587638        n = self._data[0].npol()
    … …  
    590641        draw = {"XX":0, "YY":1,"Real(XY)":2, "Imag(XY)":3}
    591642        dcirc = { "RR":0,"LL":1}#,"Real(RL)":2,"Image(RL)":3}
    592        
     643
    593644        if pol is None:
    594645            self._cursor["p"] = range(n)
    … …  
    637688            tlab = scan._getpolarizationlabel(1,0,0)
    638689        return tlab
    639            
    640 if __name__ == '__main__':
    641     plotter = asapplotter()
     690
     691    def _slice_indeces(self, data):
     692        mn = self._minmaxx[0]
     693        mx = self._minmaxx[1]
     694        asc = data[0] < data[-1]
     695        start=0
     696        end = len(data)-1
     697        inc = 1
     698        if not asc:
     699            start = len(data)-1
     700            end = 0
     701            inc = -1
     702        # find min index
     703        while data[start] < mn:
     704            start+= inc
     705        # find max index
     706        while data[end] > mx:
     707            end-=inc
     708        end +=1
     709        if start > end:
     710            return end,start
     711        return start,end
     712
     713#if __name__ == '__main__':
     714#    plotter = asapplotter()
Note: See TracChangeset for help on using the changeset viewer.