Changeset 2451


Ignore:
Timestamp:
03/30/12 19:58:59 (13 years ago)
Author:
Kana Sugimoto
Message:

New Development: No

JIRA Issue: Yes (CAS-3749)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs: unit tests of sdplot

Put in Release Notes: No

Module(s): sdplot, sdfit, sdstat, sdflag, sdcal, sdreduce

Description:

Made asapplotter not to generate plotter window at start-up, but the window is
only generated at the first invokation of plotting operation.


Location:
trunk/python
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/python/asapfitter.py

    r2409 r2451  
    544544            return
    545545        if not self._p or self._p.is_dead:
    546             #if rcParams['plotter.gui']:
    547             #    from asap.asaplotgui import asaplotgui as asaplot
    548             #else:
    549             #    from asap.asaplot import asaplot
    550             #self._p = asaplot()
    551546            from asap.asapplotter import new_asaplot
     547            del self._p
    552548            self._p = new_asaplot(rcParams['plotter.gui'])
    553549        self._p.hold()

  • trunk/python/asaplot.py

    r2146 r2451  
    77from matplotlib.backends.backend_agg import FigureCanvasAgg
    88from matplotlib.backend_bases import FigureManagerBase
     9from matplotlib import _pylab_helpers
    910
    1011class asaplot(asaplotbase):
    … …  
    2223        del v['self']
    2324        asaplotbase.__init__(self,**v)
     25        _pylab_helpers.Gcf.destroy(0)
     26        self.window = None
    2427        self.canvas = FigureCanvasAgg(self.figure)
    2528        self.figmgr = FigureManagerBase(self.canvas,1)
     29        _pylab_helpers.Gcf.figs[self.figmgr.num] = self.figmgr
    2630
    2731    def map(self):

  • trunk/python/asaplotbase.py

    r2169 r2451  
    8282
    8383        self.buffering = buffering
     84
     85        self.events = {'button_press':None,
     86                       'button_release':None,
     87                       'motion_notify':None}
    8488
    8589    def clear(self):
    … …  
    554558
    555559        The set_* methods of class Line2D define the attribute names and
    556         values.  For non-US usage, "colour" is recognized as synonymous with
    557         "color".
     560        values.  For non-US usage, 'colour' is recognized as synonymous with
     561        'color'.
    558562
    559563        Set the value to None to delete an attribute.

  • trunk/python/asaplotgui.py

    r2416 r2451  
    1111matplotlib.rcParams['toolbar'] = 'toolbar2'
    1212from matplotlib import _pylab_helpers
     13from asap.logging import asaplog, asaplog_post_dec
    1314
    1415class asaplotgui(asaplotbase):
    … …  
    2829
    2930        asaplotbase.__init__(self, **v)
     31        #matplotlib.rcParams["interactive"] = True
     32
     33        _pylab_helpers.Gcf.destroy(0)
    3034        self.window = Tk.Tk()
    31         #def dest_callback():
    32         #    print "dest_callback"
    33         #    self.is_dead = True
    34         #    self.window.destroy()
    35 
    3635        self.window.protocol("WM_DELETE_WINDOW", self.quit)
    3736        self.canvas = FigureCanvasTkAgg(self.figure, master=self.window)
    … …  
    4342        _pylab_helpers.Gcf.figs[self.figmgr.num] = self.figmgr
    4443        self._set_window_title('ASAP Plotter - Tk')
     44        self.canvas.show()
    4545
    46         self.events = {'button_press':None,
    47                        'button_release':None,
    48                        'motion_notify':None}
    49 
    50         matplotlib.rcParams["interactive"] = True
    51         #self.buffering = buffering
    52 
    53         self.canvas.show()
    5446
    5547    def map(self):
    … …  
    5850        window stack.
    5951        """
     52        if self.is_dead:
     53            raise RuntimeError( "No plotter to show. Not yet plotted or plotter is closed." )
    6054        self.window.wm_deiconify()
    6155        self.window.lift()
    … …  
    6660        """
    6761        self.is_dead = True
     62        if not self.figmgr:
     63            return
    6864        #self.window.destroy()
    6965        _pylab_helpers.Gcf.destroy(self.figmgr.num)
    70         del self.window, self.canvas
     66        del self.window, self.canvas, self.figmgr
    7167        self.window = None
    7268        self.canvas = None
    73        
     69        self.figmgr = None
    7470
    7571    def show(self, hardrefresh=True):
    … …  
    7773        Show graphics dependent on the current buffering state.
    7874        """
     75        if self.is_dead:
     76            raise RuntimeError( "No plotter to show (not yet plotted or closed)." )
    7977        if not self.buffering:
    8078            if hardrefresh:
    … …  
    8785        Clear the figure.
    8886        """
     87        if not self.window:
     88            asaplog.push( "No plotter window to terminate." )
     89            asaplog.post( "WARN" )
     90            return
    8991        self.window.destroy()
    9092
    … …  
    9395        Hide the ASAPlot graphics window.
    9496        """
     97        if not self.window:
     98            asaplog.push( "No plotter window to unmap." )
     99            asaplog.post( "WARN" )
     100            return
    95101        self.window.wm_withdraw()
    96102

  • trunk/python/asaplotgui_gtk.py

    r1819 r2451  
    1212matplotlib.rcParams['toolbar'] = 'toolbar2'
    1313from matplotlib.backends.backend_gtk import NavigationToolbar2GTK as NavigationToolbar
     14from matplotlib import _pylab_helpers
    1415
    1516class asaplotgui(asaplotbase):
    … …  
    2930
    3031        asaplotbase.__init__(self, **v)
     32        matplotlib.rcParams['interactive'] = True
    3133        matplotlib.interactive = True
     34
     35        _pylab_helpers.Gcf.destroy(0)
    3236        self.canvas = FigureCanvas(self.figure)
    3337        # Simply instantiating this is enough to get a working toolbar.
    … …  
    3943        self.window.connect("destroy", dest_callback )
    4044        self.window.set_title('ASAP Plotter - GTK')
    41         self.events = {'button_press':None,
    42                        'button_release':None,
    43                        'motion_notify':None}
    44 
    45         self.buffering = buffering
    46         matplotlib.rcParams['interactive'] = True
    4745        #self.canvas.set_size_request(800,600)
     46        _pylab_helpers.Gcf.figs[self.figmgr.num] = self.figmgr
    4847
    4948        #self.canvas.show()
    … …  
    5453        window stack.
    5554        """
     55        if self.is_dead:
     56            raise RuntimeError( "No plotter to show. Not yet plotted or plotter is closed." )
    5657        self.window.deiconify()
    5758        #self.window.lift()
    58 
    59 #     def position(self):
    60 #         """
    61 #         Use the mouse to get a position from a graph.
    62 #         """
    63 
    64 #         def position_disable(event):
    65 #             self.register('button_press', None)
    66 #             print '%.4f, %.4f' % (event.xdata, event.ydata)
    67 
    68 #         print 'Press any mouse button...'
    69 #         self.register('button_press', position_disable)
    70 
    7159
    7260    def quit(self):
    … …  
    7462        Destroy the ASAPlot graphics window.
    7563        """
    76         self.window.destroy()
    77 
    78 
    79 #     def region(self):
    80 #         """
    81 #         Use the mouse to get a rectangular region from a plot.
    82 
    83 #         The return value is [x0, y0, x1, y1] in world coordinates.
    84 #         """
    85 
    86 #         def region_start(event):
    87 #             height = self.canvas.figure.bbox.height()
    88 #             self.rect = {'fig': None, 'height': height,
    89 #                          'x': event.x, 'y': height - event.y,
    90 #                          'world': [event.xdata, event.ydata,
    91 #                                    event.xdata, event.ydata]}
    92 #             self.register('button_press', None)
    93 #             self.register('motion_notify', region_draw)
    94 #             self.register('button_release', region_disable)
    95 
    96 #         def region_draw(event):
    97 #             self.canvas._tkcanvas.delete(self.rect['fig'])
    98 #             self.rect['fig'] = self.canvas._tkcanvas.create_rectangle(
    99 #                                 self.rect['x'], self.rect['y'],
    100 #                                 event.x, self.rect['height'] - event.y)
    101 
    102 #         def region_disable(event):
    103 #             self.register('motion_notify', None)
    104 #             self.register('button_release', None)
    105 
    106 #             self.canvas._tkcanvas.delete(self.rect['fig'])
    107 
    108 #             self.rect['world'][2:4] = [event.xdata, event.ydata]
    109 #             print '(%.2f, %.2f)  (%.2f, %.2f)' % (self.rect['world'][0],
    110 #                 self.rect['world'][1], self.rect['world'][2],
    111 #                 self.rect['world'][3])
    112 
    113 #         self.register('button_press', region_start)
    114 
    115 #         # This has to be modified to block and return the result (currently
    116 #         # printed by region_disable) when that becomes possible in matplotlib.
    117 
    118 #         return [0.0, 0.0, 0.0, 0.0]
    119 
    120 
    121 #     def register(self, type=None, func=None):
    122 #         """
    123 #         Register, reregister, or deregister events of type 'button_press',
    124 #         'button_release', or 'motion_notify'.
    125 
    126 #         The specified callback function should have the following signature:
    127 
    128 #             def func(event)
    129 
    130 #         where event is an MplEvent instance containing the following data:
    131 
    132 #             name                # Event name.
    133 #             canvas              # FigureCanvas instance generating the event.
    134 #             x      = None       # x position - pixels from left of canvas.
    135 #             y      = None       # y position - pixels from bottom of canvas.
    136 #             button = None       # Button pressed: None, 1, 2, 3.
    137 #             key    = None       # Key pressed: None, chr(range(255)), shift,
    138 #                                   win, or control
    139 #             inaxes = None       # Axes instance if cursor within axes.
    140 #             xdata  = None       # x world coordinate.
    141 #             ydata  = None       # y world coordinate.
    142 
    143 #         For example:
    144 
    145 #             def mouse_move(event):
    146 #                 print event.xdata, event.ydata
    147 
    148 #             a = asaplot()
    149 #             a.register('motion_notify', mouse_move)
    150 
    151 #         If func is None, the event is deregistered.
    152 
    153 #         Note that in TkAgg keyboard button presses don't generate an event.
    154 #         """
    155 
    156 #         if not self.events.has_key(type): return
    157 
    158 #         if func is None:
    159 #             if self.events[type] is not None:
    160 #                 # It's not clear that this does anything.
    161 #                 self.canvas.mpl_disconnect(self.events[type])
    162 #                 self.events[type] = None
    163 
    164 #                 # It seems to be necessary to return events to the toolbar.
    165 #                 if type == 'motion_notify':
    166 #                     self.canvas.mpl_connect(type + '_event',
    167 #                         self.figmgr.toolbar.mouse_move)
    168 #                 elif type == 'button_press':
    169 #                     self.canvas.mpl_connect(type + '_event',
    170 #                         self.figmgr.toolbar.press)
    171 #                 elif type == 'button_release':
    172 #                     self.canvas.mpl_connect(type + '_event',
    173 #                         self.figmgr.toolbar.release)
    174 
    175 #         else:
    176 #             self.events[type] = self.canvas.mpl_connect(type + '_event', func)
    177 
     64        self.is_dead = True
     65        if not self.figmgr:
     66            return
     67        #self.window.destroy()
     68        _pylab_helpers.Gcf.destroy(self.figmgr.num)
     69        del self.window, self.canvas, self.figmgr
     70        self.window = None
     71        self.canvas = None
     72        self.figmgr = None
    17873
    17974    def show(self, hardrefresh=True):
    … …  
    18176        Show graphics dependent on the current buffering state.
    18277        """
     78        if self.is_dead:
     79            raise RuntimeError( "No plotter to show (not yet plotted or closed)." )
    18380        if not self.buffering:
    18481            if hardrefresh:
    … …  
    19289        Clear the figure.
    19390        """
     91        if not self.window:
     92            asaplog.push( "No plotter window to terminate." )
     93            asaplog.post( "WARN" )
     94            return
    19495        self.window.destroy()
    19596
    … …  
    19899        Hide the ASAPlot graphics window.
    199100        """
     101        if not self.window:
     102            asaplog.push( "No plotter window to unmap." )
     103            asaplog.post( "WARN" )
     104            return
    200105        self.window.wm_withdraw()

  • trunk/python/asaplotgui_qt4.py

    r2416 r2451  
    2929
    3030        asaplotbase.__init__(self, **v)
     31        matplotlib.rcParams["interactive"] = True
    3132
     33        _pylab_helpers.Gcf.destroy(0)
    3234        self.canvas = FigureCanvasQTAgg(self.figure)
    3335        # Simply instantiating this is enough to get a working toolbar.
    … …  
    5052        qt.QtCore.QObject.connect(self.window, qt.QtCore.SIGNAL('destroyed()'),dest_callback)
    5153
    52         self.events = {'button_press':None,
    53                        'button_release':None,
    54                        'motion_notify':None}
    55 
    56         matplotlib.rcParams["interactive"] = True
    57         self.buffering = buffering
    58 
    5954        self.unmap()
    6055        #self.canvas.show()
    … …  
    6560        window stack.
    6661        """
     62        if self.is_dead:
     63            raise RuntimeError( "No plotter to show. Not yet plotted or plotter is closed." )
    6764        self.window.activateWindow()
    6865        #To raise this window to the top of the stacking order
    … …  
    7572        """
    7673        self.is_dead = True
    77         try: self.window.close()
     74        if not self.figmgr:
     75            return
     76        try:
     77            #self.window.close()
     78            # TODO destroy casabar
     79            _pylab_helpers.Gcf.destroy(self.figmgr.num)
     80            del self.window, self.canvas, self.figmgr
     81            self.window = None
     82            self.canvas = None
     83            self.figmgr = None
    7884        except RuntimeError: pass # the window may already be closed by user
    7985
    … …  
    8288        Show graphics dependent on the current buffering state.
    8389        """
     90        if self.is_dead:
     91            raise RuntimeError( "No plotter to show (not yet plotted or closed)." )
    8492        if not self.buffering:
    8593            if hardrefresh:
    … …  
    94102        Clear the figure.
    95103        """
     104        if not self.window:
     105            asaplog.push( "No plotter window to terminate." )
     106            asaplog.post( "WARN" )
     107            return
    96108        self.window.close()
    97109
    … …  
    100112        Hide the ASAPlot graphics window.
    101113        """
     114        if not self.window:
     115            asaplog.push( "No plotter window to unmap." )
     116            asaplog.post( "WARN" )
     117            return
    102118        self.window.hide()
    103119

  • trunk/python/asapmath.py

    r2366 r2451  
    312312        asaplog.push('Plot only first spectrum for each [if,pol] pairs to verify calibration.')
    313313        asaplog.post('WARN')
    314         #p=asaplotgui.asaplotgui()
    315314        p=new_asaplot()
    316315        #nr=min(6,len(ifnos)*len(polnos))
    … …  
    532531        asaplog.push('Plot only first spectrum for each [if,pol] pairs to verify calibration.')
    533532        asaplog.post('WARN')
    534         #p=asaplotgui.asaplotgui()
    535533        p=new_asaplot()
    536534        #nr=min(6,len(ifnos)*len(polnos))
    … …  
    745743        asaplog.push('Plot only first spectrum for each [if,pol] pairs to verify calibration.')
    746744        asaplog.post('WARN')
    747         #p=asaplotgui.asaplotgui()
    748745        p=new_asaplot()
    749746        #nr=min(6,len(ifnos)*len(polnos))

  • trunk/python/asapplotter.py

    r2416 r2451  
    4545        if visible is not None:
    4646            self._visible = visible
    47         self._plotter = self._newplotter(**kwargs)
    48         # additional tool bar
    49         self._plotter.figmgr.casabar=self._new_custombar()
     47        self._plotter = None
     48        self._inikwg = kwargs
    5049
    5150        self._panelling = None
    … …  
    5554        self._rows = None
    5655        self._cols = None
    57         self._autoplot = False
    5856        self._minmaxx = None
    5957        self._minmaxy = None
    … …  
    7674        self._panelrows = []
    7775        self._headtext={'string': None, 'textobj': None}
     76        self._colormap = None
     77        self._linestyles = None
     78        self._legendloc = None
    7879
    7980    def _translate(self, instr):
    … …  
    8586        return None
    8687
    87     def _newplotter(self, **kwargs):
    88         return new_asaplot(self._visible,**kwargs)
     88    def _reload_plotter(self):
     89        if self._plotter is not None:
     90            self._plotter.clear()
     91            if self.casabar_exists():
     92                del self._plotter.figmgr.casabar
     93            self._plotter.quit()
     94            del self._plotter
     95        self._plotter = new_asaplot(self._visible,**self._inikwg)
     96        self._plotter.figmgr.casabar=self._new_custombar()
     97        # just to make sure they're set
     98        self._plotter.palette(color=0,colormap=self._colormap,
     99                              linestyle=0,linestyles=self._linestyles)
     100        self._plotter.legend(self._legendloc)
    89101
    90102    def _new_custombar(self):
    … …  
    107119        return False
    108120
     121    def _assert_plotter(self,mode="status",errmsg=None):
     122        """
     123        Check asaplot status. Returns True if plot window is alive.
     124        Parameters
     125            mode:      Mode of operation. ['status'|'reload'|'halt']
     126                       The mode 'status' simply returns if asaplot is
     127                       alive (True/False). When asaplot is not alive,
     128                       asaplot is reloaded when mode='reload', while
     129                       an error raised when mode='halt'
     130            errmsg:    An error (warning) message to send to the logger,
     131                       when asaplot is dead.       
     132        """
     133        if self._plotter and not self._plotter.is_dead:
     134            return True
     135        # Plotter is not alive.
     136        haltmsg = "Plotter window has not yet been loaded or is closed."
     137        if type(errmsg)==str and len(errmsg) > 0:
     138            haltmsg = errmsg
     139       
     140        if mode.upper().startswith("R"):
     141            # reload plotter
     142            self._reload_plotter()
     143            return True
     144        elif mode.upper().startswith("H"):
     145            # halt
     146            asaplog.push(haltmsg)
     147            asaplog.post("ERROR")
     148            raise RuntimeError(haltmsg)
     149        else:
     150            if errmsg:
     151                asaplog.push(errmsg)
     152                asaplog.post("WARN")
     153            return False
     154
     155
    109156    @asaplog_post_dec
    110157    def plot(self, scan=None):
    … …  
    119166            are consistent e.g. all 'channel' or all 'velocity' etc.
    120167        """
     168        if not self._data and not scan:
     169            msg = "Input is not a scantable"
     170            raise TypeError(msg)
    121171        self._startrow = 0
    122172        self._ipanel = -1
    123173        self._reset_header()
    124         if self._plotter.is_dead:
    125             if self.casabar_exists():
    126                 del self._plotter.figmgr.casabar
    127             self._plotter = self._newplotter()
    128             self._plotter.figmgr.casabar=self._new_custombar()
     174        self._panelrows = []
     175
     176        self._assert_plotter(mode="reload")
    129177        if self.casabar_exists():
    130178            self._plotter.figmgr.casabar.set_pagecounter(1)
    131         self._panelrows = []
     179
    132180        self._plotter.hold()
    133181        #self._plotter.clear()
    134         if not self._data and not scan:
    135             msg = "Input is not a scantable"
    136             raise TypeError(msg)
    137182        if scan:
    138183            self.set_data(scan, refresh=False)
     184        self._plotter.palette(color=0,colormap=self._colormap,
     185                              linestyle=0,linestyles=self._linestyles)
     186        self._plotter.legend(self._legendloc)
     187
    139188        self._plot(self._data)
    140189        if self._minmaxy is not None:
    … …  
    147196
    148197    def gca(self):
     198        errmsg = "No axis to retun. Need to plot first."
     199        if not self._assert_plotter(mode="status",errmsg=errmsg):
     200            return None
    149201        return self._plotter.figure.gca()
    150202
    151203    def refresh(self):
    152204        """Do a soft refresh"""
     205        errmsg = "No figure to re-plot. Need to plot first."
     206        self._assert_plotter(mode="halt",errmsg=errmsg)
     207
    153208        self._plotter.figure.show()
    154209
    … …  
    163218                        if different IFs are spread over panels (default 0)
    164219        """
    165         if self._data is None:
     220        ## this method relies on already plotted figure
     221        if not self._assert_plotter(mode="status") or (self._data is None):
     222            msg = "Cannot create mask interactively on plot. Can only create mask after plotting."
     223            asaplog.push( msg )
     224            asaplog.post( "ERROR" )
    166225            return []
    167226        outmask = []
    … …  
    210269    # forwards to matplotlib axes
    211270    def text(self, *args, **kwargs):
     271        self._assert_plotter(mode="reload")
    212272        if kwargs.has_key("interactive"):
    213273            if kwargs.pop("interactive"):
    … …  
    219279
    220280    def arrow(self, *args, **kwargs):
     281        self._assert_plotter(mode="reload")
    221282        if kwargs.has_key("interactive"):
    222283            if kwargs.pop("interactive"):
    … …  
    231292
    232293    def annotate(self, text, xy=None, xytext=None, **kwargs):
     294        self._assert_plotter(mode="reload")
    233295        if kwargs.has_key("interactive"):
    234296            if kwargs.pop("interactive"):
    … …  
    242304
    243305    def axvline(self, *args, **kwargs):
     306        self._assert_plotter(mode="reload")
    244307        if kwargs.has_key("interactive"):
    245308            if kwargs.pop("interactive"):
    … …  
    251314
    252315    def axhline(self, *args, **kwargs):
     316        self._assert_plotter(mode="reload")
    253317        if kwargs.has_key("interactive"):
    254318            if kwargs.pop("interactive"):
    … …  
    260324
    261325    def axvspan(self, *args, **kwargs):
     326        self._assert_plotter(mode="reload")
    262327        if kwargs.has_key("interactive"):
    263328            if kwargs.pop("interactive"):
    … …  
    274339
    275340    def axhspan(self, *args, **kwargs):
     341        self._assert_plotter(mode="reload")
    276342        if kwargs.has_key("interactive"):
    277343            if kwargs.pop("interactive"):
    … …  
    288354
    289355    def _axes_callback(self, axesfunc, *args, **kwargs):
     356        self._assert_plotter(mode="reload")
    290357        panel = 0
    291358        if kwargs.has_key("panel"):
    … …  
    504571        """
    505572        self._lmap = mp
    506         self._plotter.legend(mode)
     573        #self._plotter.legend(mode)
     574        self._legendloc = mode
    507575        if isinstance(fontsize, int):
    508576            from matplotlib import rc as rcp
    … …  
    513581    def set_title(self, title=None, fontsize=None, refresh=True):
    514582        """
    515         Set the title of the plot. If multiple panels are plotted,
     583        Set the title of sub-plots. If multiple sub-plots are plotted,
    516584        multiple titles have to be specified.
    517585        Parameters:
     586            title:      a list of titles of sub-plots.
     587            fontsize:   a font size of titles (integer)
    518588            refresh:    True (default) or False. If True, the plot is
    519589                        replotted based on the new parameter setting(s).
    … …  
    521591        Example:
    522592             # two panels are visible on the plotter
    523              plotter.set_title(["First Panel","Second Panel"])
     593             plotter.set_title(['First Panel','Second Panel'])
    524594        """
    525595        self._title = title
    … …  
    537607            ordinate:    a list of ordinate labels. None (default) let
    538608                         data determine the labels
     609            fontsize:    a font size of vertical axis labels (integer)
    539610            refresh:     True (default) or False. If True, the plot is
    540611                         replotted based on the new parameter setting(s).
    … …  
    542613        Example:
    543614             # two panels are visible on the plotter
    544              plotter.set_ordinate(["First Y-Axis","Second Y-Axis"])
     615             plotter.set_ordinate(['First Y-Axis','Second Y-Axis'])
    545616        """
    546617        self._ordinate = ordinate
    … …  
    559630            abcissa:     a list of abcissa labels. None (default) let
    560631                         data determine the labels
     632            fontsize:    a font size of horizontal axis labels (integer)
    561633            refresh:     True (default) or False. If True, the plot is
    562634                         replotted based on the new parameter setting(s).
    … …  
    564636        Example:
    565637             # two panels are visible on the plotter
    566              plotter.set_ordinate(["First X-Axis","Second X-Axis"])
     638             plotter.set_ordinate(['First X-Axis','Second X-Axis'])
    567639        """
    568640        self._abcissa = abcissa
    … …  
    584656                        Otherwise,the parameter(s) are set without replotting.
    585657        Example:
    586              plotter.set_colors("red green blue")
     658             plotter.set_colors('red green blue')
    587659             # If for example four lines are overlaid e.g I Q U V
    588660             # 'I' will be 'red', 'Q' will be 'green', U will be 'blue'
    589661             # and 'V' will be 'red' again.
    590662        """
    591         if isinstance(colmap,str):
    592             colmap = colmap.split()
    593         self._plotter.palette(0, colormap=colmap)
     663        #if isinstance(colmap,str):
     664        #    colmap = colmap.split()
     665        #self._plotter.palette(0, colormap=colmap)
     666        self._colormap = colmap
    594667        if refresh and self._data: self.plot(self._data)
    595668
    … …  
    604677                         is taken from the .asaprc setting
    605678                         plotter.histogram
     679            linewidth:   a line width
    606680            refresh:     True (default) or False. If True, the plot is
    607681                         replotted based on the new parameter setting(s).
    … …  
    620694        only one color has been set.
    621695        Parameters:
    622              linestyles:     a list of linestyles to use.
     696            linestyles:      a list of linestyles to use.
    623697                             'line', 'dashed', 'dotted', 'dashdot',
    624698                             'dashdotdot' and 'dashdashdot' are
    625699                             possible
     700            linewidth:       a line width
    626701            refresh:         True (default) or False. If True, the plot is
    627702                             replotted based on the new parameter setting(s).
    628703                             Otherwise,the parameter(s) are set without replotting.
    629704        Example:
    630              plotter.set_colors("black")
    631              plotter.set_linestyles("line dashed dotted dashdot")
     705             plotter.set_colors('black')
     706             plotter.set_linestyles('line dashed dotted dashdot')
    632707             # If for example four lines are overlaid e.g I Q U V
    633708             # 'I' will be 'solid', 'Q' will be 'dashed',
    634709             # U will be 'dotted' and 'V' will be 'dashdot'.
    635710        """
    636         if isinstance(linestyles,str):
    637             linestyles = linestyles.split()
    638         self._plotter.palette(color=0,linestyle=0,linestyles=linestyles)
     711        #if isinstance(linestyles,str):
     712        #    linestyles = linestyles.split()
     713        #self._plotter.palette(color=0,linestyle=0,linestyles=linestyles)
     714        self._linestyles = linestyles
    639715        if isinstance(linewidth, float) or isinstance(linewidth, int):
    640716            from matplotlib import rc as rcp
    … …  
    707783        If the spectrum is flagged no line will be drawn in that location.
    708784        """
     785        errmsg = "Cannot plot spectral lines. Need to plot scantable first."
     786        self._assert_plotter(mode="halt",errmsg=errmsg)
    709787        if not self._data:
    710788            raise RuntimeError("No scantable has been plotted yet.")
    … …  
    784862             dpi:         The dpi of the output non-ps plot
    785863        """
     864        errmsg = "Cannot save figure. Need to plot first."
     865        self._assert_plotter(mode="halt",errmsg=errmsg)
     866       
    786867        self._plotter.save(filename,orientation,dpi)
    787868        return
    … …  
    791872        """
    792873        Set a plotting mask for a specific polarization.
    793         This is useful for masking out "noise" Pangle outside a source.
     874        This is useful for masking out 'noise' Pangle outside a source.
    794875        Parameters:
    795876             mask:           a mask from scantable.create_mask
    … …  
    800881        Example:
    801882             select = selector()
    802              select.setpolstrings("Pangle")
     883             select.setpolstrings('Pangle')
    803884             plotter.set_mask(mymask, select)
    804885        """
    … …  
    13051386    @asaplog_post_dec
    13061387    def plottp(self, scan=None, outfile=None):
    1307         if self._plotter.is_dead:
    1308             if self.casabar_exists():
    1309                 del self._plotter.figmgr.casabar
    1310             self._plotter = self._newplotter()
    1311             self._plotter.figmgr.casabar=self._new_custombar()
     1388        self._assert_plotter(mode="reload")
    13121389        self._plotter.hold()
    13131390        self._plotter.clear()
    … …  
    13991476        See the method help for detailed information.
    14001477        """
     1478        self._assert_plotter(mode="reload")
    14011479        self._plotter.text(*args, **kwargs)
    14021480    # end matplotlib.Figure.text forwarding function
    … …  
    14371515
    14381516        if plot:
     1517            errmsg = "Can plot header only after the first call to plot()."
     1518            self._assert_plotter(mode="halt",errmsg=errmsg)
    14391519            self._plotter.hold()
    14401520            self._header_plot(headstr,fontsize=fontsize)
    … …  
    14691549            asaplog.push("No header has been plotted. Exit without any operation")
    14701550            asaplog.post("WARN")
    1471         else:
     1551        elif self._assert_plotter(mode="status"):
    14721552            self._plotter.hold()
    14731553            for textobj in self._headtext['textobj']:

  • trunk/python/flagplotter.py

    r2175 r2451  
    2727        self._scan = None
    2828        asapplotter.__init__(self,visible=visible, **kwargs)
     29        self._assert_plotter(mode='reload')
    2930        self._plotter._set_window_title('Flag Plotter')
    3031        self._panelling = 'r'
    … …  
    100101                         without writing the output. USE WITH CARE.
    101102        """
     103        if not self._data:
     104            raise RuntimeError("No scantable has been set yet.")
    102105        # simply calls scantable.save
    103106        self._data.save(name,format,overwrite)

  • trunk/python/interactivemask.py

    r2427 r2451  
    157157
    158158        #if not self.p._plotter or self.p._plotter.is_dead:
    159         if not self.p or self.p._plotter.is_dead:
     159        if not self.p:
    160160            asaplog.push('A new ASAP plotter will be loaded')
    161161            asaplog.post()
    … …  
    163163            self.p = asapplotter()
    164164            self.newplot = True
    165 
     165        self.p._assert_plotter(mode='reload')
     166       
    166167        # Plot selected spectra if needed
    167168        if self.scan != self.p._data:
    … …  
    171172                asaplog.post("WARN")
    172173            # Need replot
    173             self.p._plotter.legend(1)
     174            self.p._legendloc = 1
    174175            self.p.plot(self.scan)
    175176            # disable casa toolbar
Note: See TracChangeset for help on using the changeset viewer.