## Automatically adapted for scipy Oct 31, 2005 by # Copyright (c) 1996, 1997, The Regents of the University of California. # All rights reserved. See Legal.htm for full text and disclaimer. # The following more or less permanent defaults can be overruled # by assignment, provided that this file is execfile'd rather than import'ed. defgridx = "off" defgridy = "off" defthick = 1.0 defmark = " " defstyle = "solid" deflabels = 1 deflabel = None defscale = "linlin" defcolor = "fg" deftop = "" defbot = "" defleft = "" defright = "" defvsc = .5 deflev = 8 defcgm = "yes" defps = "no" _null_object_list_ = [ [], [], [], [], [], [], [], []] def _set_frame_defaults_ ( ) : global _titles_, _object_list_, _grid_type_, _axis_labels_, _axis_limits_, \ _axis_scales_, _gridx_, _gridy_, _thick_, _mark_, _style_, \ _labels_enabled_, _axis_scales_, _color_, _label_list_, _text_, \ _text_pos_, _text_size_, _text_color_, _tosys_, _cmin_, \ _cmax_, _vsc_, _lev_, _krange_, _lrange_, _kstyle_, _lstyle_, \ _region_, _default_label_, _color_bar_ _region_ = "all" _lev_ = deflev _krange_ = None _lrange_ = None _kstyle_ = "solid" _lstyle_ = "solid" _vsc_ = defvsc _titles_ = [defbot, deftop, defleft, defright] # bottom, top, left, right titles _object_list_ = [ [], [], [], [], [], [], [], []] # (ensure copy!!) # list of objects to plot (one for each possible device) _label_list_ = [] _text_ = [" "] _text_pos_ = [ [0., 0.]] _text_size_ = [0] _text_color_ = ["bg"] _tosys_ = [1] _gridx_ = defgridx _gridy_ = defgridy _grid_type_ = "axes" # grid type for current graph _axis_labels_ = ["X axis", "Y axis", "YR axis"] # axis labels _axis_limits_ = [["d","d"], ["d","d"], ["d","d"]] # axis limits; "d" implies default. _axis_scales_ = ["lin", "lin", "lin"] # axis scales _thick_ = defthick _mark_ = defmark _style_ = defstyle _labels_enabled_ = deflabels _default_label_ = " " _axis_scales_ = defscale _color_ = defcolor _cmin_ = _cmax_ = 0.0 _color_bar_ = 0 def _set_initial_defaults_ ( ) : # Set defaults global _ezcshow_, _ezcreset_, _window_, _cgm_, _ps_, _displays_, \ _ps_file_, _cgm_plotter_, _ps_plotter_, _win_plotters_, \ _current_graph_, _cgm_file_, _graphics_, _win_on_, _zt_, \ _rt_, _ireg_, _pvar_, _cindex_, _ut_, _vt_ _ezcshow_ = "true" # no plot until nf _ezcreset_ = "true" # return to initial values after nf _window_ = "no" # no window _cgm_ = defcgm # create cgm file _ps_ = defps # create postscript file _displays_ = [" ", " ", " ", " ", " ", " ", " ", " "] # hosts where display occurs _graphics_ = ["", "", "", "", "", "", "", ""] # type of graphics to use _ps_file_ = "Aa00.ps" # name of postscipt file for display _cgm_file_ = "Aa00.cgm" # name of cgm file for display _cgm_plotter_ = -1 # plotter which writes to cgm file # (subscript into _win_plotters_) _ps_plotter_ = -1 # plotter which writes to postscript file # (subscript into _win_plotters_) _win_plotters_ = [None, None, None, None, None, None, None, None] # plotters which plot to windows (max 8) # _cgm_plotter_ and _ps_plotter_ are # on this list, if they exist. _win_on_ = [0, 0, 0, 0, 0, 0, 0, 0] # windows actually activated _current_graph_ = [None, None, None, None, None, None, None, None] # current graph2d object _set_frame_defaults_ ( ) _zt_ = None _rt_ = None _ireg_ = None _pvar_ = None _cindex_ = None _ut_ = None _vt_ = None _set_initial_defaults_ ( ) GraphicsError = "GraphicsError" import os try: graphics = os.environ["PYGRAPH"] except KeyError: graphics = "Gist" from gist import * # to get mfit function if graphics [0:3] == "Nar" : import NarPlotter GistPlotter = None Graphics = NarPlotter print "Opening Narcisse graphics." elif graphics == "Gist" : import GistPlotter NarPlotter = None Graphics = GistPlotter print "Opening Gist graphics." else : raise GraphicsError , \ graphics + " is an unknown graphics package. Check PYGRAPH " + \ "environment variable." from region import * from quadmesh import * from curve import * from graph2d import * from cellarray import * import shapetest from scipy import * from numpy import ndarray from numpy.core.umath import * _ezdict_ = {'t': 'true' , 'T': 'true', 'y': 'true', 'Y': 'true', 'f': 'false', 'F': 'false', 'n': 'false', 'N': 'false'} def ezcshow (val) : global _ezcshow_, _ezdict_ EzcShowErr = "EzcShowErr" if not _ezdict_.has_key (val [0][0]) : raise EzcShowErr , \ "Illegal argument! must be 'true' or 'false'." _ezcshow_ = _ezdict_ [val [0][0]] def ezcreset (val) : global _ezcreset_, _ezdict_ EzcResetErr = "EzcResetErr" if not _ezdict_.has_key (val [0][0]) : raise EzcResetErr , \ "Illegal argument! must be 'true' or 'false'." _ezcreset_ = _ezdict_ [val [0][0]] from gistC import bytscl def ezcfmc (val) : """returns an array of indices into the current palette.""" return bytscl (val) _WinSpecError_ = "WinSpecError" def _get_free_win_number_ ( ) : # Gets the lowest number not associated with an open device, else -1. global _win_on_ try : return _win_on_.index (0) except: return -1 def _get_first_open_win_number () : # Gets the number of the lowest numbered open window, if any, else -1.. global _win_on_, _cgm_plotter_, _ps_plotter_ for i in range (8) : if _win_on_ [i] != 0 and i != _cgm_plotter_ and i != _ps_plotter_: return i return -1 def win (val , *n, **keywords) : """win (str [, n] [, display = ] [, graphics = ]) str = "on" : reserves a graphics window for display. n, if present, must be between 0 and 7 and specifies which window. if n is absent, it will default to the lowest-numbered window available. display, if present, specifies via where the window will be displayed, e. g., "icf.llnl.gov:0.0". The default is $DISPLAY. graphics, if present, specifies via which type of graphics is desired, "Nar" for Narcisse, and "Gist" for Gist being the currently allowed values. The default is $PYGRAPH if set, otherwise "Gist". str = "close" : closes a graphics window; wndow n if specified, otherwise window 0. """ global _win_on_, _displays_, _ps_plotter_, _cgm_plotter_, _graphics_, \ _win_plotters_, _object_list_ if len (n) > 0 : _window_number_ = n [0] else : if keywords.has_key ("window") : _window_number_ = keywords ["window"] else : _window_number_ = "all" if val == "on" or val == "ON" or val == "On" \ or val == "open" or val == "OPEN" or val == "Open" : _window_number_ = _check_win_ (_window_number_) if _window_number_ == []: _window_number_ = [_get_free_win_number_ ( )] if _window_number_ [0] < 0 : raise _WinSpecError_, "win ('open'): all windows are in use." for i in _window_number_: if i < 0 or i > 7 : raise _WinSpecError_, "Window number (" + `i` + \ ") is not between 0 and 7." _win_on_ [i] = 1 if keywords.has_key ("display") : _displays_ [i] = keywords ["display"] if keywords.has_key ("graphics") : _graphics_ [i] = keywords ["graphics"] if val == "off" or val == "OFF" or val == "Off" or \ val == "close" or val == "CLOSE" or val == "Close" : _window_number_ = _check_win_ (_window_number_, minmax = 1) if _window_number_ == []: _window_number_ = [0] for i in _window_number_: if i < 0 or i > 7 : raise _WinSpecError_, "win ('close'): window number (" + `i` + \ ") is not between 0 and 7." _displays_ [i] = " " _graphics_ [i] = "" _win_on_ [i] = 0 _object_list_ [i] = [] if _win_plotters_ [i] is not None : _win_plotters_ [i].close () _win_plotters_ [i] = None if i == _ps_plotter_ : _ps_plotter_ = -1 elif i == _cgm_plotter_ : _cgm_plotter_ = -1 tv = win _CgmError_ = "CgmError" def new_plot_file ( filename ) : """new_plot_file ( ) will eventually return the name of the next available file in the sequence "Aa00.ps/cgm", Ab00.ps/cgm", etc. """ if not os.path.isfile ("./" + filename) : return filename n = string.find (string.letters, filename [1]) if n == -1 or n == len (string.letters) - 1 : raise _PsError_ , "No more ps filenames available." letters = string.letters [n + 1:] OK = 0 for l in string.letters : tmpfile = filename[0:1] + l + filename[2:] if not os.path.isfile ("./" + tmpfile) : OK = 1 break if OK == 1 : return tmpfile else : raise _PsError_ , "No more ps or cgm filenames available." def _min_ ( x ) : if is_scalar (x) : return x else : return min (ravel (x)) def _max_ ( x ) : if is_scalar (x) : return x else : return max (ravel (x)) def _get_objects_ () : global _object_list_, _null_object_list_ _this_object_list_ = [] if _object_list_ != _null_object_list_ : for i in range (8): if _object_list_ [i] != [] : _this_object_list_.append (i) return _this_object_list_ def _get_open_win_list (): global _win_on_ openl = [] for i in range (len (_win_on_)) : if _win_on_ [i]: openl.append (i) return openl _BadWindow = "BadWindow" def _check_win_ (window, minmax = 0) : """_check_win_ (window) checks the integrity of the window specification, and if OK, returns a list of windows. If minmax = 0, treats "min" and "max" as errors, otherwise allows them.""" global _win_on_ if window == "all" : return _get_open_win_list () elif minmax == 1 and window == "min" : for i in range (len (_win_on_)) : if _win_on_ [i]: return [i] elif minmax == 1 and window == "max" : for i in range (len (_win_on_)) : if _win_on_ [7 - i]: return [7 - i] elif type (window) == IntType and 0 <= window <= 7: return [window] elif type (window) == ListType: err = 0 for i in range (len (window)): if type (window [i]) == IntType and 0 <= window [i] <= 7: continue else: err = 1 break if err == 0: return window raise _BadWindow, "Incorrect window specification: " + `window` + "." def _set_axis_limits_ (window = "all") : """_set_axis_limits_ ( ) makes sure legal values are used for the defaults.""" global _axis_limits_, _object_list_, _null_object_list_ ## Someday this will be improved to have a list of object lists, one for each device. _object_numbers_ = _check_win_ (window, minmax = 1) if _object_numbers_ == []: _axis_limits_ = [ [0., 0.], [0., 0.], [0., 0.]] return min_ = max_ = None for j in range (len (_object_numbers_)): if _object_list_ [j] == [] : continue for i in range (3) : if _axis_limits_ [i] == ["d", "d"] : _axis_limits_ [i] = [0., 0.] continue if _axis_limits_ [i] [0] == "d" : if i == 0 : for k in range (len (_object_list_ [j])) : new_min = _min_ (_object_list_ [j] [k].x) if min_ is None or new_min < min_ : min_ = new_min elif i == 1 : for k in range (len (_object_list_ [j])) : new_min = _min_ (_object_list_ [j] [k].y) if min_ is None or new_min < min_ : min_ = new_min elif i == 2 : min_ = 0. _axis_limits_ [i] [0] = min_ if _axis_limits_ [i] [1] == "d" : if i == 0 : for k in range (len (_object_list_ [j])) : new_max = _max_ (_object_list_ [j] [k].x) if max_ is None or new_max > max_ : max_ = new_max elif i == 1 : for k in range (len (_object_list_ [j])) : new_max = _max_ (_object_list_ [j] [k].y) if max_ is None or new_max > max_ : max_ = new_max elif i == 2 : max_ = 0. _axis_limits_ [i] [1] = max_ _CgmError_ = "CgmError" def _get_win_ (window, error): """_get_win_ (window) returns the number of a window which has a non-empty _object_list_. Has an exception if there is none--nothing to plot.""" global _object_list_ win_num = -1 if window == "min": # Find the earliest window with a nonempty list (if any) for i in range (8): if _object_list_ [i] != []: win_num = i break elif window == "max": # Find the last window with a nonempty list (if any) for i in range (8): if _object_list_ [7 - i] != []: win_num = 7 - i break elif 0 <= window <= 7: # Check for a nonempty object list: if _object_list_ [window] != [] : win_num = window else: # Find the earliest window with a nonempty list (if any) for i in range (8): if _object_list_ [i] != []: win_num = i break if win_num == -1: raise error, "There seems to be nothing there!" return win_num def cgm (val, *n, **kw) : global _cgm_, _cgm_plotter_, _current_graph_, _cgm_file_, _win_on_, \ _win_plotters, _cmin_, _cmax_, _titles_, _axis_limits_, \ _axis_labels_, _axis_scales_, _text_, _text_pos_, \ _text_size_, _text_color_, _tosys_, _grid_type_, _object_list_ if kw.has_key ("new_frame") : new_frame = kw ["new_frame"] elif _ezcshow_ == "false" : new_frame = "no" else : new_frame = "yes" if val == "on" or val == "ON" or val == "On" \ or val == "open" or val == "OPEN" or val == "Open" : _cgm_ = "yes" if len (n) == 0 : if 7 >= _cgm_plotter_ >= 0 : if _win_on_ [_cgm_plotter_] : return # a window is already assigned to cgm and is open else : _win_on_ [_cgm_plotter_] = 1 return # a window is already assigned to cgm else : _window_number_ = _get_free_win_number_ () if _window_number_ < 0 : raise _CgmError_, "No window available for cgm use." else : _window_number_ = n [0] if _window_number_ < 0 or _window_number_ > 7 : raise _CgmError_, "Window number (" + `_window_number_` + \ ") is not between 0 and 7." if 0 <= _cgm_plotter_ <= 7 : if _cgm_plotter_ == _window_number_ : return # this window is already assigned to cgm else : # another cgm window was assigned. unassign it. _win_on_ [_cgm_plotter_] = 0 if _win_plotters_ [_cgm_plotter_] is not None : _win_plotters_ [_cgm_plotter_].close () _win_plotters_ [_cgm_plotter_] = None _cgm_plotter_ = _window_number_ _win_on_ [_cgm_plotter_] = 1 return if val == "close" or val == "CLOSE" or val == "Close" : _cgm_ = "no" if 0 <= _cgm_plotter_ <= 7 : print "Closing cgm file " + _cgm_file_ + "." _win_on_ [_cgm_plotter_] = 0 if _win_plotters_ [_cgm_plotter_] is not None : _win_plotters_ [_cgm_plotter_].close () _win_plotters_ [_cgm_plotter_] = None _cgm_plotter_ = -1 return if val == "off" or val == "OFF" or val == "Off" : # Turn off transmissions to window but don't close _cgm_ = "no" return if val == "send" or val == "SEND" or val == "Send" or val == "plot" : # Figure out which object list is to be sent if _cgm_plotter_ < 0 or _object_list_ [_cgm_plotter_] == 0 and \ not kw.has_key ("window"): kw ["window"] = "min" if kw.has_key ("window") : # User has specified a window whose object list is to be plotted # or else the cgfm window doesn't have a plotting list of its own # -- guaranteed to return a valid window number; exception otherwise. win_no = _get_win_ (kw ["window"], _CgmError_) # time to send a graph to a cgm file if _cgm_plotter_ < 0 : _cgm_plotter_ = _get_free_win_number_ () if _cgm_plotter_ < 0 : raise _CgmError_, "No window available for cgm use." _win_on_ [_cgm_plotter_] = 1 if _win_plotters_ [_cgm_plotter_] is None : _cgm_file_ = new_plot_file (_cgm_file_) print "Opening plot file " + _cgm_file_ + "." _win_plotters_ [_cgm_plotter_] = \ GistPlotter.Plotter ( "none" , n = _cgm_plotter_, hcp = _cgm_file_) _win_plotters_ [_cgm_plotter_].set_bytscl (_cmin_, _cmax_) _set_axis_limits_ ( ) if _cgm_plotter_ != win_no : _object_list_ [_cgm_plotter_] = _object_list_ [win_no] if _current_graph_ [_cgm_plotter_] is None : _current_graph_ [_cgm_plotter_] = Graph2d (_object_list_ [win_no], \ plotter = _win_plotters_ [_cgm_plotter_], \ titles = _titles_, axis_limits = _axis_limits_, axis_labels = \ _axis_labels_, axis_scales = _axis_scales_, \ text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ grid_type = _grid_type_) elif val == "plot" : _current_graph_ [_cgm_plotter_].set (plotter = _win_plotters_ [_cgm_plotter_], axis_limits = _axis_limits_) else : _current_graph_ [_cgm_plotter_].new (_object_list_ [win_no], \ plotter = _win_plotters_ [_cgm_plotter_], \ text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ titles = _titles_, axis_limits = _axis_limits_, axis_labels = \ _axis_labels_, axis_scales = _axis_scales_, grid_type = _grid_type_) if new_frame == "no" : _current_graph_ [_cgm_plotter_].plot ( ) _win_plotters_ [_cgm_plotter_].plot_text ( ) if val != "plot" : # Got to turn off the file. _cgm_ = "no" import string _PsError_ = "PsError" def ps (val, *n, **kw) : global _ps_, _ps_plotter_, _current_graph_, _ps_file_, _win_on_, \ _win_plotters, _cmin_, _cmax_, _titles_, _axis_limits_, \ _axis_labels_, _axis_scales_, _text_, _text_pos_, \ _text_size_, _text_color_, _tosys_, _grid_type_, _object_list_ if kw.has_key ("new_frame") : new_frame = kw ["new_frame"] elif _ezcshow_ == "false" : new_frame = "no" if val == "on" or val == "ON" or val == "On" \ or val == "open" or val == "OPEN" or val == "Open" : _ps_ = "yes" if len (n) == 0 : if 7 >= _ps_plotter_ >= 0 : if _win_on_ [_ps_plotter_] : return # a window is already assigned to ps else : _win_on_ [_ps_plotter_] = 1 return else : _window_number_ = _get_free_win_number_ () if _window_number_ < 0 : raise _PsError_, "No window available for ps use." else : _window_number_ = n [0] if _window_number_ < 0 or _window_number_ > 7 : raise _PsError_, "Window number (" + `_window_number_` + \ ") is not between 0 and 7." if 0 <= _ps_plotter_ <= 7 : if _ps_plotter_ == _window_number_ : return # this window is already assigned to ps else : # another ps window was assigned. unassign it. _win_on_ [_ps_plotter_] = 0 if _win_plotters_ [_ps_plotter_] is not None : _win_plotters_ [_ps_plotter_].close () _win_plotters_ [_ps_plotter_] = None _ps_plotter_ = _window_number_ _win_on_ [_ps_plotter_] = 1 return if val == "off" or val == "OFF" or val == "Off" : _ps_ = "no" return if val == "close" or val == "CLOSE" or val == "Close" : _ps_ = "no" if 0 <= _ps_plotter_ <= 7 : _win_on_ [_ps_plotter_] = 0 if _win_plotters_ [_ps_plotter_] is not None : _win_plotters_ [_ps_plotter_].close () _win_plotters_ [_ps_plotter_] = None _ps_plotter_ = -1 print "Closing plot file " + _ps_file_ + "." return if val == "send" or val == "SEND" or val == "Send" or val == "plot" : # Figure out which object list is to be sent if _ps_plotter_ < 0 or _object_list_ [_ps_plotter_] == 0 and \ not kw.has_key ("window"): kw ["window"] = "min" if kw.has_key ("window") : # User has specified a window whose object list is to be plotted # or else the cgfm window doesn't have a plotting list of its own # -- guaranteed to return a valid window number; exception otherwise. win_no = _get_win_ (kw ["window"], _PsError_) # time to send a graph to a ps file if _ps_plotter_ < 0 : _ps_plotter_ = _get_free_win_number_ () if _ps_plotter_ < 0 : raise _PsError_, "No window available for ps use." _win_on_ [_ps_plotter_] = 1 if _win_plotters_ [_ps_plotter_] is None : _ps_file_ = new_plot_file (_ps_file_) print "Opening plot file " + _ps_file_ + "." _win_plotters_ [_ps_plotter_] = \ GistPlotter.Plotter ( "none" , n = _ps_plotter_, hcp = _ps_file_) _win_plotters_ [_ps_plotter_].set_bytscl (_cmin_, _cmax_) _set_axis_limits_ ( ) if _ps_plotter_ != win_no : _object_list_ [_ps_plotter_] = _object_list_ [win_no] if _current_graph_ [_ps_plotter_] is None : _current_graph_ [_ps_plotter_] = Graph2d (_object_list_ [win_no], \ plotter = _win_plotters_ [_ps_plotter_], \ titles = _titles_, axis_limits = _axis_limits_, axis_labels = \ _axis_labels_, axis_scales = _axis_scales_, \ text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ grid_type = _grid_type_) elif val == "plot" : _current_graph_ [_ps_plotter_].set (plotter = _win_plotters_ [_ps_plotter_], axis_limits = _axis_limits_) else : _current_graph_ [_ps_plotter_].new (_object_list_ [win_no], \ plotter = _win_plotters_ [_ps_plotter_], \ text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ titles = _titles_, axis_limits = _axis_limits_, axis_labels = \ _axis_labels_, axis_scales = _axis_scales_, grid_type = _grid_type_) if new_frame == "no" : _current_graph_ [_ps_plotter_].plot ( ) _win_plotters_ [_ps_plotter_].plot_text ( ) if val != "plot" : # Got to turn off the file. _ps_ = "no" _NfError_ = "NfError" _UndoError_ = "UndoError" def undo (item = None, window = "min") : """undo (item, window) removes the item-th object from window's object list, if it can. item counts starting at 1.""" global _object_list_ win_no = _get_win_ (window, _UndoError_) lo = len (_object_list_ [win_no]) if item is None : n = lo if n > lo or n < 1: raise _UndoError_, "There aren't " + `n` + " objects in the list." _object_list_ [win_no] [n - 1:n] = [] if _object_list_ [win_no] != [] and _ezcshow_ == "true" : sf (win_no) def nf ( new_frame = "yes" , window = "all" ) : global _win_plotters_, _current_graph_, _object_list_, _label_list_, \ _cmin_, _cmax_, _cgm_, _ps_, _labels_enabled_, _color_bar_, \ _win_on_, _cgm_plotter_, _ps_plotter_, _titles_, _axis_limits_, \ _axis_labels_, _axis_scales_, _text_, _text_pos_, _text_size_, \ _text_color_, _tosys_, _grid_type_, _object_list_, _graphics_, \ _current_graph_, _labels_temporarily_enabled_ enablen = zeros (8, Int) enable_cgm = 0 enable_ps = 0 if _object_list_ == _null_object_list_ : # Nothing to plot return if _cgm_ == "yes" and _cgm_plotter_ < 0 : # Open default cgm plotter print "Opening default cgm plotter." cgm ("on") if window == "cgm" : enable_cgm = 1 elif window == "ps" : enable_ps = 1 else : windows = _check_win_ (window, minmax = 1) for i in windows: enablen [i] = 1 _set_axis_limits_ ( ) for i in range (len (_win_plotters_)) : for j in range (len (_object_list_ [i])) : if _labels_temporarily_enabled_ and len (_label_list_) > j : _object_list_ [i] [j].set (label = _label_list_ [j]) _object_list_ [i] [j].set (marks = 1) else : _object_list_ [i] [j].set (label = " ") _object_list_ [i] [j].set (marks = 0) # if _object_list_ [i] [j].line_type != "none" : # _object_list_ [i] [j].set (marks = 0) if i == _cgm_plotter_ and (enable_cgm or enablen [i]) and _cgm_ : cgm ("plot", new_frame = new_frame, window = _cgm_plotter_) elif i == _ps_plotter_ and (enable_ps or enablen [i]) and _ps_ : ps ("plot", new_frame = new_frame, window = _ps_plotter_) elif enablen [i] : if _current_graph_ [i] is None : _current_graph_ [i] = Graph2d (_object_list_ [i], titles = _titles_, text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ axis_limits = _axis_limits_, axis_labels =_axis_labels_, axis_scales = _axis_scales_, grid_type = _grid_type_, color_bar = _color_bar_) else : _current_graph_ [i].new (_object_list_ [i], titles = _titles_, text = _text_, text_pos = _text_pos_, text_size = \ _text_size_, text_color = _text_color_, tosys = _tosys_, \ axis_limits = _axis_limits_, axis_labels =_axis_labels_, axis_scales = _axis_scales_, grid_type = _grid_type_, color_bar = _color_bar_) if _win_on_ [i] == 1 : if _win_plotters_ [i] is None : if _graphics_ [i] [0:3] == "Nar" : gr = NarPlotter elif _graphics_ [i] == "Gist" : gr = GistPlotter else : gr = Graphics _win_plotters_ [i] = gr.Plotter (n = i, display = _displays_ [i]) if new_frame == "no" : _win_plotters_ [i].set_bytscl (_cmin_, _cmax_) _current_graph_ [i].set (plotter = _win_plotters_ [i]) _current_graph_ [i].plot ( ) _win_plotters_ [i].plot_text ( ) if new_frame == "yes" : _object_list_ [i] = [] _label_list_ = [] if _ezcreset_ == 'true' : _set_frame_defaults_ ( ) def sf ( window = "all") : nf ("no", window = window) def display (vals) : global _displays_ if shapetest.is_scalar (vals) : _displays_ = [vals] else : _displays_ = vals def titles (* vals) : global _titles_ if len (vals) == 0 : _titles_ = [defbot, deftop, defleft, defright] elif len (vals) == 1 : _titles_ = [defbot, vals [0], defleft, defright] elif len (vals) >= 2 : _titles_ [0] = vals [1] _titles_ [1] = vals [0] if len (vals) >= 3 : _titles_ [2] = vals [2] if len (vals) >= 4 : _titles_ [3] = vals [3] else : _titles_ [3] = defright else : _titles_ [2] = defleft _titles_ [3] = defright def titleb (val) : global _titles_ _titles_ [0] = val def titlet (val) : global _titles_ _titles_ [1] = val def titlel (val) : global _titles_ _titles_ [2] = val def titler (val) : global _titles_ _titles_ [3] = val _mark_dict_ = {"dot": ".", "circle": "o", "cross": "x", "plus": "+", "asterisk": "*"} def attr ( *kw, ** keywords ) : """attr ( ) changes the values of certain keywords for the next graphics commands, until changed by keyword arguments to a plot command (changed for that command only), another attr command, or an nf (if ezcreset == "true", then attributes revert to their default values). If a keyword is a frame attribute (grid, scale, labels) then a new graph will be plotted regardless of the setting of _ezcshow_. """ global _grid_type_, _axis_scales_, _thick_, _style_, _mark_, \ _color_, _lev_, _krange_, _lrange_, _kstyle_, _lstyle_, \ _region_, _labels_enabled_, _default_label_, _object_list_, \ _null_object_list_, _win_on_ if len (kw) > 0 : keywords = kw [0] if keywords.has_key ("grid") or keywords.has_key ("scale") or \ keywords.has_key ("labels"): _nf_ = 1 else : _nf_ = 0 if keywords.has_key ("region") : _region_ = keywords ["region"] if keywords.has_key ("krange") : _krange_ = keywords ["krange"] if keywords.has_key ("lrange") : _lrange_ = keywords ["lrange"] if keywords.has_key ("kstyle") : _kstyle_ = keywords ["kstyle"] if keywords.has_key ("lstyle") : _lstyle_ = keywords ["lstyle"] if keywords.has_key ("grid"): _grid_type_ = keywords ["grid"] if _grid_type_ [0:2] == "no" : _grid_type_ = "none" elif _grid_type_ == "tickonly" : _grid_type_ = "axes" elif _grid_type_ == "xy" : _grid_type_ = "wide" else : # someday will implement x and y only _grid_type_ = "wide" if keywords.has_key ("scale"): _axis_scales_ = keywords ["scale"] if keywords.has_key ("thick"): _thick_ = keywords ["thick"] if keywords.has_key ("style"): _style_ = keywords ["style"] if keywords.has_key ("mark"): _mark_ = keywords ["mark"] if _mark_dict_.has_key (_mark_) : _mark_ = _mark_dict_ [_mark_] if keywords.has_key ("labels"): # Ignored if not either yes or no lbl = keywords ["labels"] if type (lbl) == StringType : if lbl [0] == 'y' or lbl [0] == 'Y' : _labels_enabled_ = 1 elif lbl [0] == 'n' or lbl [0] == 'N' : _labels_enabled_ = 0 if keywords.has_key ("label"): _default_label_ = keywords ["label"] if keywords.has_key ("color"): _color_ = keywords ["color"] if keywords.has_key ("lev") : _lev_ = keywords ["lev"] # Don't do the following if no windows are open yet, sf() will die. if _nf_ and _win_on_ != [0, 0, 0, 0, 0, 0, 0, 0]: # a frame trait was changed; plot the graph. # all other attributes are active only for later objects # introduced into the graph. for i in _object_list_ : if i == [] : continue # (there is nothing to graph yet) for j in range (len (i)) : # either set or reset object labels if _labels_enabled_ == 1 : i [j].set (label = _label_list_ [j]) else : i [j].set (label = " ") if _object_list_ != _null_object_list_ : sf ( ) _style_dict_ = {"solid": "solid", "dashed": "dash", "dotted" : "dot", "pm" : "solid", "none": "none", "dotdash" : "dashdot"} def plot (y = None, x = None, ** keywords) : global _grid_type_, _axis_scales_, _style_, _label_list_, \ _labels_enabled_, _default_label_, _object_list_, _style_dict_, \ _mark_dict_, _color_, _thick_, _style_, _ezcshow_, _labels_temporarily_enabled_ if y is None : attr (keywords) return if keywords.has_key ("window") : window = keywords ["window"] else : window = "all" window = _check_win_ (window, minmax = 1) mark = " " if keywords.has_key ("grid") or keywords.has_key ("scale") : # Force a newframe if either of these keywords is specified _nf_ = 1 else : _nf_ = 0 if keywords.has_key ("grid"): _grid_type_ = keywords ["grid"] if _grid_type_ [0:2] == "no" : _grid_type_ = "none" elif _grid_type_ == "tickonly" : _grid_type_ = "axes" elif _grid_type_ == "xy" : _grid_type_ = "wide" else : # someday will implement x and y only _grid_type_ = "wide" if keywords.has_key ("scale"): _axis_scales_ = keywords ["scale"] _labels_temporarily_enabled_ = _labels_enabled_ if keywords.has_key ("labels") : lbl = keywords ["labels"] if type (lbl) == StringType : if lbl [0] == 'y' or lbl [0] == 'Y' : _labels_temporarily_enabled_ = 1 elif lbl [0] == 'n' or lbl [0] == 'N' : _labels_temporarily_enabled_ = 0 if keywords.has_key ("label") : lbl = keywords ["label"] else : lbl = _default_label_ if keywords.has_key ("color") : col = keywords ["color"] else : col = _color_ # if y is a vector of coordinates lbl, x, and col should be converted to # objects of the same size. if len (shape (y)) == 1 : if no_of_dims (lbl) == 1 : lbl = lbl [0] if no_of_dims (col) == 1 : col = col [0] if x is not None and no_of_dims (x) == 2 : x = x [0] no_of_coords = 1 else : no_of_coords = shape (y) [0] if is_scalar (lbl) : lbl = [lbl] * no_of_coords elif len (lbl) < no_of_coords : lbl = lbl + [" "] * (no_of_coords - len (lbl)) if is_scalar (col) : col = [col] * no_of_coords elif len (col) < no_of_coords : col = col + [_color_] * (no_of_coords - len (col)) if x is None or isinstance(x, ndarray) and x.ndim == 1: x = [x] * no_of_coords elif shape (x) [0] < no_of_coords : x = x + [None] * no_of_coords - shape (x) [0] if keywords.has_key ("thick") : thk = keywords ["thick"] else : thk = _thick_ if keywords.has_key ("style") : stl = keywords ["style"] if stl == "dotted" : mark = "." stl = "dot" elif _style_dict_.has_key (stl) : stl = _style_dict_ [stl] # non-blank mark forced "none" hid = 0 else : if _style_dict_.has_key (_style_) : stl = _style_dict_ [_style_] else : stl = _style_ hid = 0 if keywords.has_key ("mark"): mark = keywords ["mark"] if _mark_dict_.has_key (mark) : mark = _mark_dict_ [mark] # non-blank mark forced "none" if mark != " " : hid = 0 stl = "none" if (_labels_enabled_ == 1 or _labels_temporarily_enabled_) and mark == " " \ and lbl != " " and no_of_coords == 1 and stl == "none": mark = lbl [0] for j in window: if no_of_coords == 1 : if mark == " " and not _labels_enabled_ and not _labels_temporarily_enabled_: _object_list_ [j].append (Curve (y = y, x = x, color = col, # label = lbl, type = stl, width = thk, hide = hid)) elif mark == " " and (_labels_enabled_ or _labels_temporarily_enabled_): _object_list_ [j].append (Curve (y = y, x = x, color = col, label = lbl, type = stl, marks = 1, width = thk, hide = hid)) else : _object_list_ [j].append (Curve (y = y, x = x, color = col, label = lbl, type = stl, marks = 1, marker = mark, width = thk, hide = hid)) _label_list_.append (lbl) else : for i in range (no_of_coords) : if mark == " " and not (_labels_enabled_ or _labels_temporarily_enabled_): _object_list_ [j].append (Curve (y = y [i], x = x [i], color = col [i], # label = lbl [i], type = stl, width = thk, hide = hid)) elif mark == " " and (_labels_enabled_ or _labels_temporarily_enabled_): _object_list_ [j].append (Curve (y = y [i], x = x [i], color = col [i], label = lbl [i], type = stl, marks = 1, width = thk, hide = hid)) else : _object_list_ [j].append (Curve (y = y [i], x = x [i], color = col [i], label = lbl [i], type = stl, marks = 1, marker = mark, width = thk, hide = hid)) _label_list_ = _label_list_ + lbl if _nf_ or _ezcshow_ == 'true' : sf ( window = window ) _bnd_dict_ = {"Yes" : 1 , "yes" : 1 , "YES" : 1 , "y" : 1 , "Y" : 1 , "ON" : 1 , "On" : 1 , "on" : 1 , 1 : 1, "No" : 0 , "no" : 0 , "NO" : 0 , "n" : 0 , "N" : 0 , "None" : 0 , "none" : 0 , "NONE" : 0 , "OFF" : 0 , "off" : 0 , "Off" : 0 , 0 : 0 } _SetMeshError_ = "SetMeshError" def set_mesh ( ** keywords ) : """set_mesh (rt = , zt = , ireg = , ut = , vt = , pvar = , cindex = ) defines a two-dimensional mesh for plotting. rt and zt are real, two-dimensional arrays of the same shape defining the mesh. ireg is a two-dimensional integer array defining which region of the mesh each quadrilateral in it belongs to. It should be the same shape as rt and zt, but the first row and first column are constrained to be 0. ut and vt are velocity components used to plot vector fields. pvar and cindex are mutually exclusive. pvar is a real array used to color a filled mesh, while cindex is a character array whose components specify an index into a color table. All arrays must be the same shape. Once set, these variables will define the mesh until the next set_mesh command. Any variable undefined by set_mesh must be supplied as a keyword argument to a plot command or must have been previously defined by a set_mesh command. A variable defined by set_mesh can be overruled temporarily by a keyword argument to a plot command. Variables set by set_mesh will remain defaults unless they are overruled by keyword arguments to plot commands or until they are changed permanently by another set_mesh or by a clear_mesh. """ global _zt_, _rt_, _ut_, _vt_, _ireg_, _pvar_, _cindex_ if keywords.has_key ("zt") : _zt_ = keywords ["zt"] else : _zt_ = None if keywords.has_key ("rt") : _rt_ = keywords ["rt"] else : _rt_ = None if keywords.has_key ("ut") : _ut_ = keywords ["ut"] else : _ut_ = None if keywords.has_key ("vt") : _vt_ = keywords ["vt"] else : _vt_ = None if keywords.has_key ("ireg") : _ireg_ = keywords ["ireg"] else : _ireg_ = None if keywords.has_key ("pvar") and keywords.has_key ("cindex") : raise _SetMeshError_, "Only one of 'pvar' and 'cindex' is allowed." if keywords.has_key ("pvar") : _pvar_ = keywords ["pvar"] _cindex_ = None elif keywords.has_key ("cindex") : _cindex_ = keywords ["cindex"] _pvar_ = None def clear_mesh ( ) : global _zt_, _rt_, _ireg_, _pvar_, _cindex_, _ut_, _vt_ _zt_ = None _rt_ = None _ireg_ = None _pvar_ = None _cindex_ = None _ut_ = None _vt_ = None def ezcx (val) : global _zt_ _zt_ = val def ezcy (val) : global _rt_ _rt_ = val def ezcpvar (val) : global _pvar_ _pvar_ = val def ezccindex (val) : global _cindex_ _cindex_ = val def ezcireg (val) : global _ireg_ _ireg_ = val def ezcu (val ) : global _ut_ _ut_ = val def ezcv (val ) : global _vt_ _vt_ = val _MeshDefError_ = "MeshDefError" _FillError_ = "FillError" def _minm_ (x) : """_minm_ (x) computes and returns something guaranteed smaller than the minimum element in the array x.""" min_ = min (ravel (x)) if min_ == 0 : return -1 elif min_ > 0 : return min_ - .01 * min_ else : return min_ + .01 * min_ _PlotfError_ = "PlotfError" _RangeError_ = "RangeError" def plotm (*kwds, ** keywords) : global _grid_type_, _axis_scales_, _cmin_, _cmax_, _krange_, _lrange_, \ _region_, _color_bar_, _labels_enabled_, _zt_, _rt_, _ut_, _vt_, \ _ireg_, _pvar_, _cindex_, _object_list_, _labels_temporarily_enabled_ _labels_temporarily_enabled_ = _labels_enabled_ if len (kwds) != 0 : keywords = kwds [0] if keywords.has_key ("window") : window = keywords ["window"] else : window = "all" window = _check_win_ (window, minmax = 1) if keywords.has_key ("color_bar") : _color_bar_ = keywords ["color_bar"] if keywords.has_key ("contour_plot") and keywords ["contour_plot"] != 0 : cp = 1 else : cp = 0 if keywords.has_key ("lev") : __lev_ = keywords ["lev"] else : __lev_ = _lev_ if keywords.has_key ("fill") : if _bnd_dict_.has_key (keywords ["fill"]) : _fill_ = _bnd_dict_ [keywords ["fill"]] else : raise _FillError_, "Unknown value <" + `keywords ["fill"]` + \ "> for keyword 'fill.'" else : _fill_ = 0 if keywords.has_key ("zt") : __zt_ = keywords ["zt"] else : __zt_ = _zt_ if keywords.has_key ("rt") : __rt_ = keywords ["rt"] else : __rt_ = _rt_ if keywords.has_key ("ut") : __ut_ = keywords ["ut"] else: __ut_ = _ut_ if keywords.has_key ("vt") : __vt_ = keywords ["vt"] else: __vt_ = _vt_ if keywords.has_key ("ireg") : __ireg_ = keywords ["ireg"] else : __ireg_ = _ireg_ if __zt_ is None and __rt_ is not None and cp == 0 : raise _MeshDefError_, "zt is missing from the mesh.\n" + \ "Use set_mesh command or zt keyword in plotm command." elif __zt_ is not None and __rt_ is None and cp == 0 : raise _MeshDefError_, "rt is missing from the mesh.\n" + \ "Use set_mesh command or rt keyword in plotm command." elif __zt_ is None and __rt_ is None and cp == 0 : raise _MeshDefError_, "Both zt and rt are missing from the mesh.\n" + \ "Use set_mesh command or rt and zt keywords in plotm command." if _fill_ == 0 and cp == 0 : __pvar_ = _pvar_ __cindex_ = _cindex_ if _fill_ == 1 or cp == 1 : # look for either pvar or cindex. __pvar_ = None __cindex_ = None if keywords.has_key ("pvar") : __pvar_ = keywords ["pvar"] elif keywords.has_key ("cindex") : __cindex_ = keywords ["cindex"] else : __pvar_ = _pvar_ __cindex_ = _cindex_ if __pvar_ is not None : k = shape (__pvar_) [0] l = shape (__pvar_) [1] elif __cindex_ is not None : k = shape (__cindex_) [0] l = shape (__cindex_) [1] else : raise _MeshDefError_, "Neither pvar nor cindex has been specified." if __ireg_ is None and __zt_ is not None : # Default to a single region if _fill_ == 0 : k = shape (__zt_) [0] l = shape (__zt_) [1] __ireg_ = ones ( (k, l), Int) __ireg_ [:, 0] = 0 __ireg_ [0, :] = 0 _z_ = None __krange_ = _krange_ __lrange_ = _lrange_ if keywords.has_key ("krange"): __krange_ = keywords ["krange"] if len (__krange_) >= 1 : klo = __krange_ [0] if klo < 0 or klo > shape (__ireg_) [0] : raise _RangeError_, `klo` + " is an illegal low subscript." if len (__krange_) >= 2 : khi = __krange_ [1] if khi < 0 or khi > shape (__ireg_) [0] : raise _RangeError_, `khi` + " is an illegal high subscript." if len (__krange_) >= 3 : kstr = __krange_ [2] if kstr < 0 or kstr > shape (__ireg_) [0] : raise _RangeError_, `kstr` + " is an illegal stride." else : kstr = 1 else : khi = shape (__ireg_) [0] else : raise _RangeError_, "<" + `__krange_` + "> is an illegal range." if keywords.has_key ("lrange"): __lrange_ = keywords ["lrange"] if len (__lrange_) >= 1 : llo = __lrange_ [0] if llo < 0 or llo > shape (__ireg_) [1] : raise _RangeError_, `llo` + " is an illegal low subscript." if len (__lrange_) >= 2 : lhi = __lrange_ [1] if lhi < 0 or lhi > shape (__ireg_) [1] : raise _RangeError_, `lhi` + " is an illegal high subscript." if len (__lrange_) >= 3 : lstr = __lrange_ [2] if lstr < 0 or lstr > shape (__ireg_) [1] : raise _RangeError_, `lstr` + " is an illegal stride." else : lstr = 1 else : lhi = shape (__ireg_) [1] else : raise _RangeError_, "<" + `__lrange_` + "> is an illegal range." if __krange_ is not None and __lrange_ is None : llo = 0 lhi = shape (__ireg_) [1] lstr = 1 __lrange_ = (llo, lhi, lstr) elif __krange_ is None and __lrange_ is not None : klo = 0 khi = shape (__ireg_) [0] kstr = 1 __krange_ = (klo, khi, kstr) # These attributes are sticky, so set the globals _krange_ = __krange_ _lrange_ = __lrange_ if __krange_ is not None : # All the data must be resized __ireg_ = __ireg_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] if __zt_ is not None : __zt_ = __zt_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] if __rt_ is not None : __rt_ = __rt_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] if __ut_ is not None : __ut_ = __ut_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] __vt_ = __vt_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] if __pvar_ is not None : __pvar_ = __pvar_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] elif __cindex_ is not None: __cindex_ = __cindex_ [klo:khi + 1:kstr, llo:lhi + 1:lstr] _cscale_ = None if _fill_ == 1 or cp == 1 : # look for either pvar or cindex. if keywords.has_key ("cscale") : _cscale_ = keywords ["cscale"] else : _cscale_ = "lin" if _cscale_ != "lin" and __pvar_ is None : raise _PlotfError_, \ "pvar keyword must be present if cscale is not 'lin.'" if __pvar_ is not None : _z_ = __pvar_ elif __cindex_ is not None : _z_ = __cindex_ if keywords.has_key ("edges") : _edges_ = keywords ["edges"] if keywords.has_key ("ewidth") : _ewidth_ = keywords ["ewidth"] else : _ewidth_ = 1 if keywords.has_key ("ecolor") : _ecolor_ = keywords ["ecolor"] else : _ecolor_ = "fg" else : _edges_ = 0 _ewidth_ = 0 _ecolor_ = "bg" mark = " " if keywords.has_key ("grid") or keywords.has_key ("scale") : # Force a newframe if either of these keywords is specified _nf_ = 1 else : _nf_ = 0 if keywords.has_key ("grid"): _grid_type_ = keywords ["grid"] if _grid_type_ [0:2] == "no" : _grid_type_ = "none" elif _grid_type_ == "tickonly" : _grid_type_ = "axes" elif _grid_type_ == "xy" : _grid_type_ = "wide" else : # someday will implement x and y only _grid_type_ = "wide" if keywords.has_key ("scale"): _axis_scales_ = keywords ["scale"] else : _axis_scales_ = "linlin" if keywords.has_key ("style") : stl = keywords ["style"] if stl == "dotted" : mark = "." elif _style_dict_.has_key (stl) : stl = _style_dict_ [stl] hid = stl == "none" else : stl = "solid" hid = 0 if keywords.has_key ("bnd") and _bnd_dict_.has_key (keywords ["bnd"]) : bnd = _bnd_dict_ [keywords ["bnd"]] else : bnd = 0 # default kstyle and lstyle depend on setting of bnd. if bnd == 1 : _kstyle_ = "none" _lstyle_ = "none" else : _kstyle_ = stl _lstyle_ = stl if keywords.has_key ("kstyle"): _kstyle_ = keywords ["kstyle"] if _style_dict_.has_key (_kstyle_) : _kstyle_ = _style_dict_ [_kstyle_] if keywords.has_key ("lstyle"): _lstyle_ = keywords ["lstyle"] if _style_dict_.has_key (_lstyle_) : _lstyle_ = _style_dict_ [_lstyle_] _inhibit_ = 0 if _kstyle_ == "none" : _inhibit_ = _inhibit_ + 1 if _lstyle_ == "none" : _inhibit_ = _inhibit_ + 2 if keywords.has_key ("thick") : thk = keywords ["thick"] else : thk = _thick_ if keywords.has_key ("color") : col = keywords ["color"] else : col = _color_ if keywords.has_key ("labels") : lbl = keywords ["labels"] else : lbl = " " if keywords.has_key ("mark"): _mark_ = keywords ["mark"] else : _mark_ = " " if keywords.has_key ("marksize"): _marksize_ = keywords ["marksize"] if keywords.has_key ("region"): __region_ = keywords ["region"] _region_ = __region_ # sticky else : __region_ = _region_ if keywords.has_key ("vsc"): __vsc_ = keywords ["vsc"] else : __vsc_ = _vsc_ if is_scalar (__region_) and __region_ != "all" : __region_ = [__region_] elif __region_ == "all" and bnd == 1 : # We need to make up a list of valid region numbers. # This is only for the boundary case--Gist only does # the outside boundary if region == 0, contrary to its # specifications. __region_ = [] n = shape (__ireg_) [0] m = shape (__ireg_) [1] for i in range (n) : for j in range (m) : if __ireg_ [i,j] != 0 and not __ireg_ [i, j] in __region_ : __region_.append (__ireg_ [i, j]) filled = 0 contours = 0 if cp == 1 and col [0:4] == "fill" : contours = filled = 1 col = "fg" elif cp == 1 and col == "fillnl" : filled = 1 col = "fg" elif cp == 1 : contours = 1 if cp == 1 : _fill_ = filled if __region_ != "all" : # Plot the indicated regions _region_list_ = [] for i in range (len (__region_)) : if _mark_ == " " and _labels_enabled_ == 0 : _region_list_.append ( Region (number = __region_ [i], boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , width = thk, label = lbl, hide = hid, contours = contours, levels = __lev_)) elif _mark_ == " " and _labels_enabled_ == 1 : _region_list_.append ( Region (number = __region_ [i], boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, width = thk, label = lbl, hide = hid, marks = 1, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , contours = contours, levels = __lev_)) else : _region_list_.append ( Region (number = __region_ [i], boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, width = thk, label = lbl, hide = hid, marks = 1, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , marker = _mark_, contours = contours, levels = __lev_)) for j in window : _object_list_ [j].append (QuadMesh (x = __zt_, y = __rt_, ireg = __ireg_, vx = __vt_, vy = __ut_, scale = __vsc_, z_scale = _cscale_, regions = _region_list_, filled = _fill_, contours = contours, levels = __lev_, z = _z_)) else : # Plot the whole mesh for j in window : if _mark_ == " " and _labels_enabled_ == 0 : _object_list_ [j].append (QuadMesh (x = __zt_, y = __rt_, ireg = __ireg_, vx = __vt_, vy = __ut_, scale = __vsc_, regions = __region_, boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , width = thk, label = lbl, hide = hid, z = _z_, contours = contours, levels = __lev_, z_scale = _cscale_)) elif _mark_ == " " and _labels_enabled_ == 1 : _object_list_ [j].append (QuadMesh (x = __zt_, y = __rt_, ireg = __ireg_, vx = __vt_, vy = __ut_, scale = __vsc_, regions = __region_, boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, z_scale = _cscale_, width = thk, label = lbl, hide = hid, marks = 1, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , z = _z_, contours = contours, levels = __lev_)) else : _object_list_ [j].append (QuadMesh (x = __zt_, y = __rt_, ireg = __ireg_, vx = __vt_, vy = __ut_, scale = __vsc_, regions = __region_, boundary = bnd, boundary_type = stl, boundary_color = col, inhibit = _inhibit_, type = stl, color = col, z_scale = _cscale_, width = thk, label = lbl, hide = hid, marks = 1, ktype = _kstyle_, ltype = _lstyle_, filled = _fill_ , marker = _mark_, z = _z_, contours = contours, levels = __lev_)) _label_list_.append (lbl) if _nf_ or _ezcshow_ == 'true' : sf ( window = window ) _PlotvError_ = "PlotvError" def plotv (*args, **keywords) : """plotv ( [zt [, rt [, vt [,ut [, ireg]]]]], ) plots vectors on a mesh.""" rt = _rt_ zt = _zt_ ut = _ut_ vt = _vt_ ireg = _ireg_ if not keywords.has_key ("kstyle") : keywords ["kstyle"] = "none" if not keywords.has_key ("lstyle") : keywords ["lstyle"] = "none" if len (args) > 0 : zt = args [0] keywords ["zt"] = zt if len (args) > 1 : rt = args [1] keywords ["rt"] = rt if len (args) > 2 : vt = args [2] keywords ["vt"] = vt if len (args) > 3 : ut = args [3] keywords ["ut"] = ut if len (args) > 4 : ireg = args [4] keywords ["ireg"] = ireg elif keywords.has_key ("ireg") : ireg = keywords ["ireg"] elif keywords.has_key ("ut") : ut = keywords ["ut"] elif keywords.has_key ("vt") : vt = keywords ["vt"] elif keywords.has_key ("rt") : rt = keywords ["rt"] else : if keywords.has_key ("zt") : zt = keywords ["zt"] if keywords.has_key ("rt") : rt = keywords ["rt"] if keywords.has_key ("ut") : ut = keywords ["ut"] if keywords.has_key ("vt") : vt = keywords ["vt"] if rt is None : raise _PlotvError_, "rt has not been defined. Use set_mesh, or pass\n" + \ "as second argument or keyword argument to plotv." if zt is None : raise _PlotvError_, "zt has not been defined. Use set_mesh, or pass\n" + \ "as first argument or keyword argument to plotv." if ut is None : raise _PlotvError_, "ut has not been defined. Use set_mesh, or pass\n" + \ "as fourth argument or keyword argument to plotv." if vt is None : raise _PlotvError_, "vt has not been defined. Use set_mesh, or pass\n" + \ "as third argument or keyword argument to plotv." plotm ( keywords ) def plotb (** keywords) : """plotb ( ) is the same as plotm with the keyword bnd = 1, i. e., plot the boundary of the mesh. """ keywords ["bnd"] = 1 plotm ( keywords ) _PlotcError_ = "PlotcError" def plotc (** keywords) : """plotc ( ) is similar to plotm; however, it adds to the keywords in such a way that plotm will do a contour plot. As in plotf, zt and rt may have been specified as one dimensional, and if so, they need to be expanded to two dimensions. """ global _lev_, _pvar_ if keywords.has_key ("pvar") : (k, l) = shape (keywords ["pvar"]) elif _pvar_ is not None : (k, l) = shape (_pvar_) else : raise _PlotcError_ , "pvar keyword must be specified or " + \ "pvar must be defined by set_mesh." if keywords.has_key ("zt") : x = keywords ["zt"] if no_of_dims (x) == 1 : if len (x) != k : raise _PlotcError_, "Length of zt <" + `len (x)` + \ "> does not match first dimension of pvar <" + `k` + ">." keywords ["zt"] = multiply.outer (x, ones (l)) elif shape (y) != (k, l) : raise _PlotcError_, "zt has a funny shape: " + `shape (y)` + \ "." if keywords.has_key ("rt") : y = keywords ["rt"] if no_of_dims (y) == 1 : if len (y) != l : raise _PlotcError_, "Length of rt <" + `len (y)` + \ "> does not match first dimension of pvar <" + `l` + ">." keywords ["rt"] = multiply.outer (ones (k), y) elif shape (x) != (k, l) : raise _PlotcError_, "rt has a funny shape: " + `shape (x)` + \ "." keywords ["kstyle"] = "none" keywords ["lstyle"] = "none" keywords ["contour_plot"] = 1 if keywords.has_key ("lev") : lev = keywords ["lev"] else : lev = _lev_ if lev == "lin" or lev == "linear" : lev = deflev if lev == "log" or type (lev) == IntType and lev < 0 : keywords ["cscale"] = "log" if lev == "log" : lev = deflev else : lev = - lev keywords ["lev"] = lev plotm (keywords) _PlotzError_ = "PlotzError" def plotz (* args, **keywords) : """plotz (z [,x [,y]], ) is the non mesh-oriented contour plot. keyword pvar will be set to z, rt will be set to x (if present), and zt will be set to y (if present). If x or y or both are 1d, they will be expanded to a 2d mesh. This is so that plotm can be used.""" global _lev_ keywords ["kstyle"] = "none" keywords ["lstyle"] = "none" keywords ["contour_plot"] = 1 if len (args) != 0 : z = args [0] elif keywords.has_key ("z") : z = keywords ["z"] del keywords ["z"] else : raise _PlotzError_, "No z argument was given for plotz!!" if len (args) > 1 : x = args [1] if len (args) > 2 : y = args [2] else : y = None else : x = None y = None if x is not None and y is not None and \ len (x.shape) == len (y.shape) == len (z.shape) == 1 and \ x.shape == y.shape == z.shape: # random data; turn into a regular mesh. xmax = max (x) xmin = min (x) ymax = max (y) ymin = min (y) nx = min (int (sqrt (len (x))) + 1, 50) ny = nx dx = (xmax - xmin) / nx dy = (ymax - ymin) / ny xcplot = span (xmin, xmax - dx, nx) ycplot = span (ymin, ymax - dy, ny) del xmin, xmax, ymin, ymax, dx, dy xt = subtract.outer (x, x) yt = subtract.outer (y, y) aa = sqrt (xt * xt + yt * yt + rsq) del xt, yt alpha = array (z, copy = 1) alpha = solve_linear_equations (aa, alpha) z = mfit (alpha, x, xcplot, y, ycplot, rsq) del aa, alpha, rsq # Expand coordinates to 2d arrays to match zcplot x = multiply.outer (xcplot, ones (ny, Float)) y = multiply.outer (ones (nx, Float), ycplot) del xcplot, ycplot, nx, ny keywords ["pvar"] = z (k, l) = shape (z) if x is not None and len (shape (x)) == 1 : if len (x) != k : raise _PlotzError_, "length of x <" + `len (x)` + \ "> does not match first dimension of z <" + `k` + ">." x = multiply.outer (x, ones (l, Float)) elif x is None : x = multiply.outer (arange (1, k + 1, dtype = Float), ones (l, Float)) if y is not None and len (shape (y)) == 1 : if len (y) != l : raise _PlotzError_, "length of y <" + `len (y)` + \ "> does not match second dimension of z <" + `l` + ">." y = multiply.outer (ones (k, Float), y) elif y is None : y = multiply.outer (ones (k, Float), arange (1, l + 1, dtype = Float)) keywords ["zt"] = y keywords ["rt"] = x if keywords.has_key ("lev") : lev = keywords ["lev"] else : lev = _lev_ if lev == "lin" or lev == "linear" : lev = deflev if lev == "log" or type (lev) == IntType and lev < 0 : keywords ["cscale"] = "log" if lev == "log" : lev = deflev else : lev = - lev keywords ["lev"] = lev plotm (keywords) _PlotiError_ = "PlotiError" def ploti (* pvar, ** keywords) : """ploti (pvar, ) is the cell array plot.""" global _object_list_, _ezcshow_, _pvar_, _labels_enabled_, \ _labels_temporarily_enabled_ _labels_temporarily_enabled_ = _labels_enabled_ if _object_list_ != _null_object_list_ : raise _PlotiError_, "Cell array plot can't be superposed with others." if len (pvar) > 0 : pvar = pvar [0] elif keywords.has_key ("pvar") : pvar = keywords ["pvar"] elif _pvar_ is not None : pvar = _pvar_ else : pvar = _cindex_ if keywords.has_key ("window") : window = keywords ["window"] else : window = "all" window = _check_win_ (window, minmax = 1) if keywords.has_key ("style") : hid = keywords ["style"] == "none" else : hid = 0 if keywords.has_key ("labels") : lbl = keywords ["labels"] else : lbl = " " for j in window: _object_list_ [j].append ( CellArray (z = pvar, hide = hid, label = lbl)) if _ezcshow_ == 'true' : sf ( window = window ) def plotf (*args, ** keywords) : """plotf ( arg1 [,arg2 [,arg3 [,arg4 ]]] [,] ) is the same as plotm with the keyword fill = 1, i. e., plot a filled mesh. arg1 if integer is an array which gives color numbers; if real, gives the values of a real variable which will be used to interpolate into the current palette. arg2, if present, is zt. arg3, if present, is rt. arg4, if present, is ireg.""" global _zt_, _rt_, _pvar_ n = len (args) __zt_ = _zt_ __rt_ = _rt_ if n != 0 : if type (args[0][0][0]) == IntType : plvar = keywords ["cindex"] = array(args [0],'B') # Gist knows chars else : plvar = keywords ["pvar"] = args [0] if n > 1 : __zt_ = keywords ["zt"] = args [1] if n > 2 : __rt_ = keywords ["rt"] = args [2] if n > 3 : keywords ["ireg"] = args [3] elif keywords is not None and not keywords.has_key ("cindex") \ and not keywords.has_key ("pvar") and _pvar_ is None : raise _PlotfError_, "plotf requires at least one non-keyword " + \ "argument\n or else one of the keywords 'cindex' or 'pvar.'" elif not keywords.has_key ("cindex") and not keywords.has_key ("pvar") \ and _pvar_ is not None : plvar = keywords ["pvar"] = _pvar_ elif keywords.has_key ("cindex") : plvar = keywords ["cindex"] else : plvar = keywords ["pvar"] # zt and rt might not be specified, or else thay are vectors. # They must be 2d and match plvar in shape. (k, l) = shape (plvar) if shape (__zt_) != shape (plvar) : if __zt_ is None: __zt_ = multiply.outer (arange (1, k + 1, dtype = Float), ones (l, Float)) elif no_of_dims (__zt_) == 1 : if len (__zt_) != k : raise _PlotfError_, "Length of zt <" + `len (__zt_)` + \ "> does not match first dimension of pvar <" + `k` + ">." __zt_ = multiply.outer (__zt_, ones (l, Float)) else : raise _PlotfError_, "zt has a funny shape: " + `shape (__zt_)` + \ "." keywords ["zt"] = __zt_ if shape (__rt_) != shape (plvar) : if __rt_ is None: __rt_ = multiply.outer (ones (k, Float), arange (1, l + 1, dtype = Float)) elif no_of_dims (__rt_) == 1 : if len (__rt_) != l : raise _PlotfError_, "Length of rt <" + `len (__rt_)` + \ "> does not match second dimension of pvar <" + `l` + ">." __rt_ = multiply.outer (ones (k, Float), __rt_) else : raise _PlotfError_, "rt has a funny shape: " + `shape (__rt_)` + \ "." keywords ["rt"] = __rt_ keywords ["fill"] = 1 plotm ( keywords ) def frame ( *args , ** keywords ) : """frame ( [xmin [, xmax [, ymin [, ymax]]]] [, ) has the effect of changing the axis limits of the current graph. The limits may be expressed by positional arguments or by keyword arguments. The limits are effective immediately on the current graph and disappear on the next one. Any limits not set by this command will default to the maximum and the minimum of the data. """ global _axis_limits_ if keywords.has_key ("window") : window = keywords ["window"] else : window = "all" window = _check_win_ (window, minmax = 1) if keywords.has_key ("xmin") : _axis_limits_ [0] [0] = keywords ["xmin"] elif len (args) > 0 : _axis_limits_ [0] [0] = args [0] else : _axis_limits_ [0] [0] = "d" if keywords.has_key ("xmax") : _axis_limits_ [0] [1] = keywords ["xmax"] elif len (args) > 1 : _axis_limits_ [0] [1] = args [1] else : _axis_limits_ [0] [1] = "d" if keywords.has_key ("ymin") : _axis_limits_ [1] [0] = keywords ["ymin"] elif len (args) > 2 : _axis_limits_ [1] [0] = args [2] else : _axis_limits_ [1] [0] = "d" if keywords.has_key ("ymax") : _axis_limits_ [1] [1] = keywords ["ymax"] elif len (args) > 3 : _axis_limits_ [1] [1] = args [3] else : _axis_limits_ [1] [1] = "d" sf ( window = window ) def fr ( *args , ** keywords ) : """fr ( [xmin [, xmax [, ymin [, ymax]]]] [, ) is the equivalent of nf ( ) followed by frame with the same set of arguments.""" global _axis_limits_ if keywords.has_key ("window") : window = keywords ["window"] else : window = "all" window = _check_win_ (window, minmax = 1) nf ( window = window ) if keywords.has_key ("xmin") : _axis_limits_ [0] [0] = keywords ["xmin"] elif len (args) > 0 : _axis_limits_ [0] [0] = args [0] else : _axis_limits_ [0] [0] = "d" if keywords.has_key ("xmax") : _axis_limits_ [0] [1] = keywords ["xmax"] elif len (args) > 1 : _axis_limits_ [0] [1] = args [1] else : _axis_limits_ [0] [1] = "d" if keywords.has_key ("ymin") : _axis_limits_ [1] [0] = keywords ["ymin"] elif len (args) > 2 : _axis_limits_ [1] [0] = args [2] else : _axis_limits_ [1] [0] = "d" if keywords.has_key ("ymax") : _axis_limits_ [1] [1] = keywords ["ymax"] elif len (args) > 3 : _axis_limits_ [1] [1] = args [3] else : _axis_limits_ [1] [1] = "d" sf ( window = window ) def text (str, rt, zt, size, tosys = 1, color = "fg", window = "all") : """text (str, zt, rt, size [, tosys]) plots the specified string starting at (zt, rt) in point size 'size.' If tosys is specified and nonzero, then coordinates are not window-relative.""" global _text_, _text_pos_, _text_color_, _text_size_, _tosys_, _ezcshow_ _text_.append (str) _text_pos_.append ([rt, zt]) _text_color_.append (color) _text_size_.append (size) _tosys_.append (tosys) if _ezcshow_ == 'true' : sf ( window = window ) def list_devices ( ) : global _win_on_, _win_plotters_, _cgm_file_, _cgm_, _ps_file_, _ps_, \ _cgm_plotter_, _ps_plotter_, _graphics_, _displays_ if _win_on_ == [0, 0, 0, 0, 0, 0, 0, 0] : print "No devices are currently open." return for i in range (len (_win_plotters_) ) : if i == _cgm_plotter_ : if _cgm_ == "yes" : op = "on" else : op = "off" print "device %d: cgm file '%s', currently %s." % \ (i, _cgm_file_, op) elif i == _ps_plotter_ : if _ps_ == "yes" : op = "on" else : op = "off" print "device %d: ps file '%s', currently %s." % \ (i, _ps_file_, op) elif _win_on_ [i] : if _graphics_ [i] [0:3] == "Nar" or Graphics == NarPlotter : gr = "Narcisse" elif _graphics_ [i] == "Gist" or Graphics == GistPlotter : gr = "Gist" else : gr = Graphics print "device %d: %s Xwindow for display '%s'." % \ (i, gr, _displays_ [i]) return