## 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. import narcisse from scipy import * from numpy.core.umath import * # We need types to check args to some routines from types import * from graftypes import * from shapetest import * from gistfuncs import * from string import uppercase import os def minmax1 ( x ) : """minmax1 (x) where x is a one-dimensional array computes the minimum and maximum values in the array and returns them as a list [min, max]. """ max = x [0] min = x [0] for i in range (len (x)) : if x [i] > max : max = x[i] if x [i] < min : min = x [i] return [floor (min), ceil (max)] def minmax2 ( x ) : """minmax2 (x) where x is a two-dimensional array computes the minimum and maximum values in the array and returns them as a list [min, max]. I use this routine because there are apparently some circumstances in which Gist fails to calculate default axis limits correctly. """ max = x [0, 0] min = x [0, 0] for i in range (shape (x) [0]) : for j in range (shape (x) [1]) : if x [i, j] > max : max = x [i, j] if x [i, j] < min : min = x [i, j] return [floor (min), ceil (max)] NarFloat = 'f' NarInt = 'i' # Define a simple title function: missing arguments become blanks. class Plotter : def type (self) : return NarType def open ( self , filename = ' ' ) : """open ( string ) opens a connection to Narcisse (if it can) using filename 'string.' """ if self._file_open : if self._file_name == filename : return # quietly else : raise self.ConnectException , \ "This instance already open with filename '" + \ self._file_name + "'." else : self._file_descr = narcisse.naropen ( filename ) if self._file_descr >= 0 : self._file_open = 1 self._file_name = filename else : raise self.ConnectException , \ "Unable to open graphics file '" + filename + "'." _cgm_warning = 0 _ps_warning = 0 def __init__ ( self , filename = ' ' , ** kw ) : self.NarError = "NarError" if filename == "none" : if not self._cgm_warning : print "Sorry, Narcisse does not write cgm files." print "...This will be your only warning." self._cgm_warning = 1 elif len (filename) >= 3 and filename [-3:] == ".ps" : if not self._ps_warning : print "Sorry, Narcisse does not write postscript files" print "except from the graphical user interface." print "...This will be your only warning." self._ps_warning = 1 self._file_open = 0 self._frozen = 0 self._freeze_each = 0 self._mono = 0 #defaults to color self._file_descr = -1 self.ConnectException = "ConnectException" self.open ( filename ) self.freeze_graph ( ) self.set_grid_type ( "axes" ) self._xyequal = 0 self.set_default_axes_limits () # let Narcisse determine limits self.set_axis_lin ("all") # all axes linear scales narcisse.narsetar ( "curve_label_x_min", 0.2 ) narcisse.narsetar ( "curve_label_x_max", 0.2 ) narcisse.narsetar ( "curve_label_y_min", 0.2 ) narcisse.narsetar ( "curve_label_y_max", 0.2 ) narcisse.narsetvals ( self._file_descr ) self._x_axis_min = 0. self._y_axis_min = 0. self._yr_axis_min = 0. self._z_axis_min = 0. self._c_axis_min = 0. self._x_axis_max = 0. self._y_axis_max = 0. self._yr_axis_max = 0. self._z_axis_max = 0. self._c_axis_max = 0. self.clear_text ( ) self.set_text_color (2, 0) #black or nearly so self.set_axis_labels () # To English defaults self.set_titles ( ) self.set_title_colors ( ) self.plot_curve = self.plot_object self.add_curve = self.add_object self._graph_type = 0 if kw.has_key ("style") : self._style = kw ["style"] else : self._style = " " self._next_letter = 0 def close ( self ) : "close () closes the connection to Narcisse." if self._file_open : narcisse.narclose ( self._file_descr ) self._file_descr = -1 self._file_open = 0 self._file_name = "" def __del__ ( self ) : self.close ( ) def new_frame (self) : return def set_tosys (self, *x) : return def set_mono ( self ) : """set_mono () will set the 3d display mode permanently to monochrome mesh. This is the only meaningful display mode if you are only displaying 3d data on a monochrome monitor. Calls to set_3d_options will do nothing (silently). Call set_color () to allow color options again.""" self.set_3d_options ( color_bar, color_bar_pos, "wm" ) self._mono = 1 def synchronize ( self ) : if self._file_open : narcisse.narsync ( self._file_descr ) else : print "synchronize: sorry, nothing is open to synchronize with." def query ( self ) : if not self._file_open : return -1 else : return narcisse.narquery ( self._file_name ) def set_color ( self ) : """set_color ( ) will allow you to use the color 3d options which are disabled by set_mono ( ).""" self._mono = 0 # Everything on a 2d graph shares the same color card: # (This dictionary is used to convert Narcisse color card names # to the numbers required by the plotting routines. It will also # convert Gist names.) narcisse_color_card_dict = { "absolute" : 0 , "binary" : 1 , "bluegreen" : 2 , "default" : 6 , "negative" : 4 , "positive" : 5 , "rainbow" : 6 , "rainbowhls" : 7 , "random" : 8 , "redblue" : 9 , "redgreen" : 10 , "shifted" : 11 ,"earth.gp" : 8 , "stern.gp" : 2 , "rainbow.gp" : 7 , "heat.gp" : 10 , "gray.gp" : 0 , "yarg.gp" : 4 } def set_color_card ( self , h , now = 0) : """set_color_card ( n ) indicates a predefined color card for a plot. See the manual for the values of n and the color card selected (sec. 4.2.134, parametre_map).""" if self.narcisse_color_card_dict.has_key (h) : h = self.narcisse_color_card_dict [h] narcisse.narsetai ("parameter_map", h) narcisse.narsetvals (self._file_descr) def set_titles ( self , * vals ): """set_titles ('bottom', 'top', 'left', 'right') All arguments are optional. Missing ones default to ' '.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len (vals) == 0 : vals = [] elif type (vals [0]) == StringType : vals = [vals [0]] else : vals = vals [0] if len (vals) == 0 : vals = [ " " , " " , " " , " " ] elif len (vals) == 1 : vals = vals + [ " " , " " , " " ] elif len (vals) == 2 : vals = vals + [ " " , " " ] elif len (vals) == 3 : vals = vals + [ " " ] elif len (vals) <> 4 : print "titles must be one string or a list of up to four strings!" return narcisse.narsetac ( "title_value_bottom" , vals [0] ) narcisse.narsetac ( "title_value_top" , vals [1] ) narcisse.narsetac ( "title_value_left" , vals [2] ) narcisse.narsetac ( "title_value_right" , vals [3] ) narcisse.narsetvals ( self._file_descr ) # Translation table from color names to Narcisse (only works for rainbowhls) gist_to_narcisse_col = { "bg" : 0, "background" : 0, "fg" : 1, "foreground" : 1, "blue" : 2, "green" : 3, "yellow" : 4 , "orange" : 5 , "red" : 6, "magenta" : 7, "purple" : 7, "black" : 8, "white" : 9, "cyan" : 20 , "yellowgreen" : 39, "gold" : 42 , "orangered" : 47, "redorange" : 48, -1 : 0 , -2 : 1 , -3 : 8 , -4 : 9 , -5 : 6 , -6 : 3 , -7 : 2 , -8 : 20 , -9 : 7 , -10 : 4 } def _figure_color (self , col) : """_figure_color ( col ) does the best job it can to return a correct color. If the value is legal for Narcisse (even though it may mean something else in another system) then it is returned unchanged. If it is a Gist value, it is converted to Narcisse if possible. In all other cases, return 1. """ if type (col) == IntType and 0 <= col <= 63 : return col if self.gist_to_narcisse_col.has_key (col) : return self.gist_to_narcisse_col [col] return 1 def set_title_colors ( self , * vals ) : """set_title_colors (bottom_color, top_color, left_color, right_color) All arguments are optional, integers from 0 to 63 representing a color in some color map. Missing arguments default to foreground.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len (vals) == 0 : vals = [] elif type (vals [0]) == IntType : vals = [vals [0]] else : vals = vals [0] if len (vals) == 0 : vals = [ 1 , 1 , 1 , 1 ] elif len (vals) == 1 : vals = [vals [0]] + [ 1 , 1 , 1 ] elif len (vals) == 2 : vals = [vals [0]] + [vals [1]] + [ 1 , 1 ] elif len (vals) == 3 : vals = [vals [0]] + [vals [1]] + [vals [2]] + [ 1 ] elif len (vals) <> 4 : raise self.NarError ,\ "Title color must be list of size 4 or less." else : vals = [vals [0]] + [vals [1]] + [vals [2]] + [vals [3]] for i in range (4) : vals[i] = self._figure_color (vals [i]) narcisse.narsetai ( "title_color_bottom" , vals [0] ) narcisse.narsetai ( "title_color_top" , vals [1] ) narcisse.narsetai ( "title_color_left" , vals [2] ) narcisse.narsetai ( "title_color_right" , vals [3] ) narcisse.narsetvals ( self._file_descr ) def set_grid_type ( self , * val ) : """set_grid_type ( string ) determines how intrusive the axes and grids are. The legal arguments are: 'none'--no axes and grids are drawn. 'axes'--axes with tick marks. 'wide'--widely spaced grid in x and y (2d or 3d). 'full'--narrowly spaced grid in x and y (2d or 3d). If no argument is specified, the default is 'axes'.""" if len ( val ) > 1 : raise self.NarError , "Too many arguments to set_grid_type." if len ( val ) == 0 or val [0] == "axes" : narcisse.narsetai ( "grid_type" , 1 ) elif val [0] == "none" : narcisse.narsetai ( "grid_type" , 0 ) elif val [0] == "wide" : narcisse.narsetai ( "grid_type" , 2 ) elif val [0] == "full" : narcisse.narsetai ( "grid_type" , 3 ) else : raise self.NarError , val [0] + \ " is an inappropriate argument for set_grid_type." narcisse.narsetvals ( self._file_descr ) def set_3d_grid_type ( self , val ) : """set_3d_grid_type (gt) sets what the wire grid will look like in a 3d surface plot in one of the wire modes. The choices for gt are 'x' (x lines only), 'y' (y lines only) and 'xy' (both x and y lines).""" if val == "x" : narcisse.narsetai ( "option_3d_grid_type" , 0 ) elif val == "y" : narcisse.narsetai ( "option_3d_grid_type" , 1 ) else : # You'll get "xy" if you goof. narcisse.narsetai ( "option_3d_grid_type" , 2 ) narcisse.narsetvals ( self._file_descr ) def set_connect ( self , val ) : """set_connect (cn) tells whether to connect two or more surface plots, which presumably improves masking. cn=1 to connect, cn=0 to disconnect.""" narcisse.narsetai ("option_3d_conv_mode" , val) narcisse.narsetvals ( self._file_descr ) def set_link ( self , val ) : """set_link (ln) tells whether to link two or more surfaces plotted with different 3d options into one plot (otherwise all surfaces will have the same options). ln=1 to link, ln = 0 not to link. This needs to be set to 1 for all surfaces except the last. Connection must not be set (see set_connect ()). The axes must not be plotted for surfaces after the first.""" narcisse.narsetai ("parameter_scene", val) narcisse.narsetvals ( self._file_descr ) def set_z_c_switch ( self , val ) : """set_z_c_switch (sw) tells whether to switch the roles of the z and c variables in a 4d plot. sw=1 to do the switch, sw=0 not to do it.""" narcisse.narsetai ("option_3d_z_or_c", val) narcisse.narsetvals ( self._file_descr ) # routine to label the axes def set_axis_labels ( self , * vals ): """set_axis_labels ('x_label', 'y_label', 'z_label', 'yr_label') All arguments are optional. Default values (from right): ' ', 'Z axis', 'Y axis', 'X axis'.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len (vals) == 1 and (type (vals [0]) == TupleType or type (vals [0]) == ListType) : valsin = vals[0] else : valsin = vals vals = [ "X axis" , "Y axis" , "Z axis" , " " ] if len (valsin) >= 1 : vals [0] = valsin [0] if len (valsin) >= 2 : vals [1] = valsin [1] if len (valsin) >= 3 : vals [2] = valsin [2] narcisse.narsetac ( "x_axis_title" , vals [0] ) narcisse.narsetac ( "y_axis_title" , vals [1] ) narcisse.narsetac ( "z_axis_title" , vals [2] ) narcisse.narsetac ( "yr_axis_title" , vals [3] ) narcisse.narsetvals ( self._file_descr ) # routines to set axis scales -- linear scales def set_axis_lin ( self , ax ) : """set_axis_lin (ax) where ax can be 'x', 'y', 'yr', 'z', 'c', or 'all'. The specified axis will have a linear scale.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if ( ax == "x" ) : narcisse.narsetai ( "x_axis_log" , 0 ) elif ( ax == "y" ) : narcisse.narsetai ( "y_axis_log" , 0 ) elif ( ax == "yr" ) : narcisse.narsetai ( "yr_axis_log" , 0 ) elif ( ax == "z" ) : narcisse.narsetai ( "z_axis_log" , 0 ) elif ( ax == "c" ) : narcisse.narsetai ( "c_axis_log" , 0 ) elif ax == "all" : narcisse.narsetai ( "x_axis_log" , 0 ) narcisse.narsetai ( "y_axis_log" , 0 ) narcisse.narsetai ( "yr_axis_log" , 0 ) narcisse.narsetai ( "z_axis_log" , 0 ) narcisse.narsetai ( "c_axis_log" , 0 ) else : raise self.NarError , "set_axis_lin: axis must be x, y, yr, z, or c." narcisse.narsetvals ( self._file_descr ) # routines to set axis scales -- log scales def set_axis_log ( self , ax ) : """set_axis_log (ax) where ax can be 'x', 'y', 'yr', 'z', 'c', or 'all'. The specified axis will have a logarithmic scale.""" if ( ax == "x" ) : narcisse.narsetai ( "x_axis_log" , 1 ) elif ( ax == "y" ) : narcisse.narsetai ( "y_axis_log" , 1 ) elif ( ax == "yr" ) : narcisse.narsetai ( "yr_axis_log" , 1 ) elif ( ax == "z" ) : narcisse.narsetai ( "z_axis_log" , 1 ) elif ( ax == "c" ) : narcisse.narsetai ( "c_axis_log" , 1 ) elif ax == "all" : narcisse.narsetai ( "x_axis_log" , 1 ) narcisse.narsetai ( "y_axis_log" , 1 ) narcisse.narsetai ( "yr_axis_log" , 1 ) narcisse.narsetai ( "z_axis_log" , 1 ) narcisse.narsetai ( "c_axis_log" , 1 ) else : raise self.NarError , "axis_log: axis must be x, y, yr, z, or c." narcisse.narsetvals ( self._file_descr ) # special routines to set both x and y scales at once def set_linlin ( self ) : "set_linlin () sets both x and y axes to linear scale." self.set_axis_lin ( "x" ) self.set_axis_lin ( "y" ) def set_linlog ( self ) : 'set_linlog () sets x axis to linear, y axis to logarithmic.' self.set_axis_lin ( "x" ) self.set_axis_log ( "y" ) def set_loglin ( self ) : 'set_loglin () sets x axis to logarithmic, y axis to linear.' self.set_axis_log ( "x" ) self.set_axis_lin ( "y" ) def set_loglog ( self ) : 'set_loglog () sets both x and y axes to logarithmic scale.' self.set_axis_log ( "x" ) self.set_axis_log ( "y" ) #determine which y axis to use for a curve def set_y_axis ( self , val1 , * val2 ) : """use set_y_axis ( 'left' , n ) or set_y_axis ( 'right' , n ) to cause curve number n to be associated with the left or right y axis.""" if len ( val2 ) == 2 : n = val2 [1] else : n = 0 # set for curve 0 if not specified if len ( val2 ) == 0 or val2 [0] == "left" or val2 [0] != "right" : narcisse.narsetaii ( "curve_y_axis" , 0 , n ) else : narcisse.narsetaii ( "curve_y_axis" , 1 , n ) narcisse.narsetvals ( self._file_descr ) def set_bytscl ( self, cmin, cmax ) : return def add_text (self, str, x, y, size, color="fg", tosys = 1) : """add_text (str, x, y, size [, color]) adds a text to a graph.""" return # set the maximum value of an axis def set_axis_max ( self , ax , * val1 ) : """set_axis_max (ax, val) where ax is 'x', 'y', 'z', 'yr', or 'c'. The maximum of the specified axis will be set to val. val should be a PyFloat object.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val1 ) == 0 : val = 0.0 else : val = val1 [0] if ( ax == "x" ) : self._x_axis_max = val narcisse.narsetar ( "x_axis_max" , val ) elif ( ax == "y" ) : self._y_axis_max = val narcisse.narsetar ( "y_axis_max" , val ) elif ( ax == "yr" ) : self._yr_axis_max = val narcisse.narsetar ( "yr_axis_max" , val ) elif ( ax == "z" ) : self._z_axis_max = val narcisse.narsetar ( "z_axis_max" , val ) elif ( ax == "c" ) : self._c_axis_max = val narcisse.narsetar ( "c_axis_max" , val ) else : raise self.NarError , "set_axis_max: axis must be x, y, yr, z, or c." # narcisse.narsetvals ( self._file_descr ) # set the minimum value of an axis def set_axis_min ( self , ax , * val1 ) : '''set_axis_min (ax, val) where ax is "x", "y", "z", "yr", or "c". The minimum of the specified axis will be set to val. val should be a PyFloat object.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val1 ) == 0 : val = 0.0 else : val = val1 [0] if ( ax == "x" ) : self._x_axis_min = val narcisse.narsetar ( "x_axis_min" , val ) elif ( ax == "y" ) : self._y_axis_min = val narcisse.narsetar ( "y_axis_min" , val ) elif ( ax == "yr" ) : self._yr_axis_min = val narcisse.narsetar ( "yr_axis_min" , val ) elif ( ax == "z" ) : self._z_axis_min = val narcisse.narsetar ( "z_axis_min" , val ) elif ( ax == "c" ) : self._c_axis_min = val narcisse.narsetar ( "c_axis_min" , val ) else : raise self.NarError , "set_axis_min: axis must be x, y, yr, z, or c." # narcisse.narsetvals ( self._file_descr ) # Send axes limits at the last moment before a plot def _send_axes_limits ( self ) : narcisse.narsetar ( "x_axis_max" , self._x_axis_max ) narcisse.narsetar ( "x_axis_min" , self._x_axis_min ) narcisse.narsetar ( "y_axis_max" , self._y_axis_max ) narcisse.narsetar ( "y_axis_min" , self._y_axis_min ) narcisse.narsetar ( "yr_axis_max" , self._yr_axis_max ) narcisse.narsetar ( "yr_axis_min" , self._yr_axis_min ) narcisse.narsetar ( "z_axis_max" , self._z_axis_max ) narcisse.narsetar ( "z_axis_min" , self._z_axis_min ) narcisse.narsetar ( "c_axis_max" , self._c_axis_max ) narcisse.narsetar ( "c_axis_min" , self._c_axis_min ) # narsetvals will be done in send_graph # Allow Narcisse to calculate the axis limits def set_default_axes_limits ( self , * h ) : '''set_default_axes_limits () sets narcisse to compute the maximum and minimum of the axes depending on the data.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if self._xyequal : # compute xy limits myself xdist = self._x_axis_max - self._x_axis_min ydist = self._y_axis_max - self._y_axis_min if xdist > ydist : self._y_axis_max = self._y_axis_max + xdist - ydist elif ydist > xdist : self._x_axis_max = self._x_axis_max + ydist - xdist narcisse.narsetar ( "x_axis_max" , self._x_axis_max ) narcisse.narsetar ( "y_axis_max" , self._y_axis_max ) narcisse.narsetar ( "x_axis_min" , self._x_axis_min ) narcisse.narsetar ( "y_axis_min" , self._y_axis_min ) # narcisse.narsetvals ( self._file_descr ) else : narcisse.narsetar ( "x_axis_max" , 0.0 ) narcisse.narsetar ( "y_axis_max" , 0.0 ) narcisse.narsetar ( "yr_axis_max" , 0.0 ) narcisse.narsetar ( "z_axis_max" , 0.0 ) narcisse.narsetar ( "c_axis_max" , 0.0 ) narcisse.narsetar ( "x_axis_min" , 0.0 ) narcisse.narsetar ( "y_axis_min" , 0.0 ) narcisse.narsetar ( "yr_axis_min" , 0.0 ) narcisse.narsetar ( "z_axis_min" , 0.0 ) narcisse.narsetar ( "c_axis_min" , 0.0 ) # narcisse.narsetvals ( self._file_descr ) # routines to set the limits on individual axes def set_x_axis_limits ( self , val1 , * val2i ) : '''set_x_axis_limits (min, max) sets the limits on the x axis to the specified (pyFloat) sizes.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val2i ) == 0 : val2 = 0.0 else : val2 = val2i [0] self._x_axis_min = val1 self._x_axis_max = val2 narcisse.narsetar ( "x_axis_max" , val2) narcisse.narsetar ( "x_axis_min" , val1 ) # narcisse.narsetvals ( self._file_descr ) def set_y_axis_limits ( self , val1 , * val2i ) : '''set_y_axis_limits (min, max) sets the limits on the y axis to the specified (pyFloat) sizes.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val2i ) == 0 : val2 = 0.0 else : val2 = val2i [0] self._y_axis_min = val1 self._y_axis_max = val2 narcisse.narsetar ( "y_axis_max" , val2) narcisse.narsetar ( "y_axis_min" , val1 ) # narcisse.narsetvals ( self._file_descr ) def set_yr_axis_limits ( self , val1 , * val2i ) : '''set_yr_axis_limits (min, max) sets the limits on the yr axis to the specified (pyFloat) sizes.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val2i ) == 0 : val2 = 0.0 else : val2 = val2i [0] self._yr_axis_min = val1 self._yr_axis_max = val2 narcisse.narsetar ( "yr_axis_max" , val2) narcisse.narsetar ( "yr_axis_min" , val1 ) # narcisse.narsetvals ( self._file_descr ) def set_z_axis_limits ( self , val1 , * val2i ) : '''set_z_axis_limits (min, max) sets the limits on the z axis to the specified (pyFloat) sizes.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val2i ) == 0 : val2 = 0.0 else : val2 = val2i [0] self._z_axis_min = val1 self._z_axis_max = val2 narcisse.narsetar ( "z_axis_max" , val2) narcisse.narsetar ( "z_axis_min" , val1 ) # narcisse.narsetvals ( self._file_descr ) def set_c_axis_limits ( self , val1 , * val2i ) : '''set_c_axis_limits (min, max) sets the limits on the c axis to the specified (pyFloat) sizes.''' if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val2i ) == 0 : val2 = 0.0 else : val2 = val2i [0] self._c_axis_min = val1 self._c_axis_max = val2 narcisse.narsetar ( "c_axis_max" , val2) narcisse.narsetar ( "c_axis_min" , val1 ) # narcisse.narsetvals ( self._file_descr ) # stuff to help set 3d options # (1) These are the legal arguments and their values if wire shows legal_3d_options = { 'wm' : 0 , 'w3' : 1 , 'w4' : 3 , 'f3' : 8 , \ 'f4' : 16 , 'i3' : 32 , 'i4' : 64 , 's3' : 128 , \ 's4' : 256 , 'none' : 0} # (2) These are the values of the other arguments if there is no wire legal_3d_no_wire = { 'f3' : 7 , 'f4' : 15 , 'i3' : 31 , 'i4' : 63 , \ 's3' : 127 , 's4' : 255 } # (3) The following arguments can occur together; the values given # are used if there is no wire showing. (If wire is present, # the values in legal_3d_options are simply or'ed. legal_3d_double = { 'f3' : { 'i3' : 39 , 'i4' : 71 } , 'f4' : { 'i3' : 47 , 'i4' : 79 } , 'i3' : { 'f3' : 39 , 'f4' : 47 } , 'i4' : { 'f3' : 71 , 'f4' : 79 } } def set_3d_options ( self , color_bar , color_bar_pos , * vals ) : """set_3d_options (args) may be called with no argument, a single string argument, or a sequence of up to three strings. If called with no arguments, the graph display is erased. A surface is colored by height in z if a 3d option is specified, and by the value of a given function if a 4d option is specified. With a wire grid option, the grid is colored; with a flat option, the quadrilaterals set off by grid lines are colored; with a smooth option, the surface itself is colored by height; and with an iso option, the contour lines are colored. flat and iso options may be used together in any combination. wire grid options are independent of the other options. Legal arguments for set_3d_options are: 'wm'--monochrome wire grid; 'w3' and 'w4'--3d and 4d coloring of wire grid. 'f3' and 'f4'--flat 3d and 4d coloring options. 'i3' and 'i4'--3d and 4d isoline (contour line) options. 's3' and 's4'--3d and 4d smooth coloring options.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if self._mono == 1 : return if len (vals) == 0 : vals = ["wm"] elif is_scalar (vals) : vals = [vals [0]] else : vals = vals [0] if is_scalar (vals) : vals = [vals] if len (vals) > 3 : raise self.NarError , "set_3d_options: too many arguments" wire_option = -1 # If this ever gets sent, the graph vanishes option = 0 c_color_bar = 0 z_color_bar = 0 for i in range ( len (vals) ) : if vals [i] == "s4" or vals [i] == "i4" : c_color_bar = color_bar if vals [i] == "s3" or vals [i] == "i3" : z_color_bar = color_bar if not self.legal_3d_options.has_key ( vals [i] ) : raise self.NarError , "set_3d_options: "\ + vals [i] + " is an illegal option." if self.legal_3d_options [vals [i]] <= 3 : wire_option = self.legal_3d_options [vals [i]] if wire_option != -1 : for i in range ( len (vals) ) : option = option | self.legal_3d_options [vals [i]] elif len (vals) >= 1 : if len (vals) == 1 : option = self.legal_3d_no_wire [vals [0]] elif not self.legal_3d_double.has_key [vals [0]] or \ not self.legal_3d_double [vals [0]].has_key (vals [1]) : print "set_3d_options: illegal combination of options: " \ + vals [0] + " and " + vals [1] + "." return else : option = self.legal_3d_double [vals [0]][vals [1]] else : # cause graph to commit suicide if no args given option = -1 # at this point the arguments were legal and 'option' has been set. narcisse.narsetai ( "option_3d" , option ) # check out whether a color bar is wanted : if c_color_bar : if color_bar_pos is not None : c_color_bar = 1 narcisse.narsetai ( "height_c_x_min", color_bar_pos [0, 0]) narcisse.narsetai ( "height_c_y_min", color_bar_pos [0, 1]) narcisse.narsetai ( "height_c_x_max", color_bar_pos [1, 0]) narcisse.narsetai ( "height_c_x_max", color_bar_pos [1, 1]) else : c_color_bar = 2 narcisse.narsetai ( "height_c_type", c_color_bar ) elif z_color_bar : if color_bar_pos is not None : z_color_bar = 1 narcisse.narsetai ( "height_z_x_min", color_bar_pos [0, 0]) narcisse.narsetai ( "height_z_y_min", color_bar_pos [0, 1]) narcisse.narsetai ( "height_z_x_max", color_bar_pos [1, 0]) narcisse.narsetai ( "height_z_x_max", color_bar_pos [1, 1]) else : z_color_bar = 2 narcisse.narsetai ( "height_z_type", z_color_bar ) else : narcisse.narsetai ( "height_c_type", 0) narcisse.narsetai ( "height_z_type", 0) narcisse.narsetvals ( self._file_descr ) # Some other routines to set stuff relating to 3d options def set_z_contours ( self , val ) : """set_z_contours (arg) sets various properties when doing 3d contour (iso), smooth, or flat plots. It accepts one argument, as follows: if an integer n, sets the number of contours to n. This also clears the contour levels array. Countour levels will be computed automatically from the data. if a string: 'lin' plots the contours linearly spaced. 'log' plots the contours logarithmically spaced. if an array NarFloat: sets the contour levels to the values in the array.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if type ( val ) == IntType : for i in range ( val ) : narcisse.narsetari ("height_z", 0.0 , i ) narcisse.narsetvals ( self._file_descr ) return elif type ( val ) == StringType : if val == "log" : narcisse.narsetai ("height_z_log", 1) narcisse.narsetvals ( self._file_descr ) return elif val == "lin" : narcisse.narsetai ("height_z_log", 0) narcisse.narsetvals ( self._file_descr ) return elif type ( val ) == ArrayType : val = val.astype (NarFloat) if len (val.shape) == 1 : # Note: when setting a Narcisse array you must do a narsetvals # after setting each element. If instead you send a whole list # of values all at once, then only the last takes effect and # all lower values in the table are cleared. for i in range (val.shape [0]) : narcisse.narsetari ("height_z", val [i] , i) narcisse.narsetvals ( self._file_descr ) narcisse.narsetar ("height_z_h_min", val [0]) narcisse.narsetar ("height_z_h_max", val [val.shape [0]-1]) narcisse.narsetvals ( self._file_descr ) return raise self.NarError , "Wrong type of argument to set_z_contours." def set_c_contours ( self , val ) : """set_c_contours (arg) sets various properties when doing 4d contour (iso), smooth, or flat plots. It accepts one argument, as follows: if an integer n, sets the number of contours to n. This also clears the contour levels array. Countour levels will be computed automatically from the data. if a string: 'lin' plots the contours linearly spaced. 'log' plots the contours logarithmically spaced. if an Array NarFloat: sets the contour levels to the values in the array.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if type ( val ) == IntType : for i in range (val) : narcisse.narsetari ("height_c", 0.0 , i ) narcisse.narsetvals ( self._file_descr ) return elif type ( val ) == StringType : if val == "log" : narcisse.narsetai ("height_c_log", 1) narcisse.narsetvals ( self._file_descr ) return elif val == "lin" : narcisse.narsetai ("height_c_log", 0) narcisse.narsetvals ( self._file_descr ) return elif type ( val ) == ArrayType : val = val.astype (NarFloat) if len (val.shape) == 1 : # Note: when setting a Narcisse array you must do a narsetvals # after setting each element. If instead you send a whole list # of values all at once, then only the last takes effect and # all lower values in the table are cleared. for i in range (val.shape [0]) : narcisse.narsetari ("height_c", val [i] , i) narcisse.narsetvals ( self._file_descr ) narcisse.narsetar ("height_c_h_min", val [0]) narcisse.narsetar ("height_c_h_max", val [val.shape [0]-1]) narcisse.narsetvals ( self._file_descr ) return raise self.NarError , "Wrong type of argument to set_c_contours." # set the mask (hidden line remover) for 3d def set_mask ( self , * val ) : """set_mask (arg) determines whether hidden parts of the surface will be shown on the graph, and if not, what algorithm will be used to determine what is hidden. The allowed arguments and masking algorithm are as follows: 'none'--no masking. in wire grid mode, all grid lines are visible. 'min'--the surface is traced beginning in the corner closest to the observer. 'max'--the surface is traced beginning in the corner farthest from the observer. 'sort'--a cell sorting is carried out to determine the masking.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 or val [0] == "none" : narcisse.narsetai ( "option_3d_mask_type" , 0 ) # default: no mask elif val [0] == "min" : narcisse.narsetai ( "option_3d_mask_type" , 1 ) # minimum mask elif val [0] == "max" : narcisse.narsetai ( "option_3d_mask_type" , 2 ) # maximum mask elif val [0] == "sort" : narcisse.narsetai ( "option_3d_mask_type" , 3 ) # sorted mask else : raise self.NarError , val [0] + " is not a valid mask type." narcisse.narsetvals ( self._file_descr ) # Set language def set_language ( self , * val ) : """set_language (arg) determines what language the Narcisse GUI will be displayed in. Called with no argument, it sets the language to English. Otherwise it may be called with 'English', 'French', 'anglais', or 'francaise'. In a concession to the lazy among us, 'english' and 'french' are also allowed.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 or val [0] == "English" or val [0] == "english" : narcisse.narsetac ( "language" , "anglais" ) elif val [0] == "French" or val [0] == "french" : narcisse.narsetac ( "language" , "francais" ) else : # let the user commit suicide narcisse.narsetac ( "language" , val [0] ) narcisse.narsetvals ( self._file_descr ) # commands to set the angle of view: def set_phi ( self , * val ) : """set_phi (arg) sets the angle of view, measured from the positive z axis. If called with no argument, phi is set to 45 degrees. Otherwise it should be called with an integer argument (the angle in degrees).""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 or val [0] is None : narcisse.narsetar ( "height" , 30.0 ) else : narcisse.narsetar ( "height" , 90.0 - val [0] ) narcisse.narsetvals ( self._file_descr ) def set_theta ( self , * val ) : """set_theta (arg) sets the angle of view, measured from the positive x axis. If called with no argument, theta is set to 45 degrees. Otherwise it should be called with an integer argument (the angle in degrees).""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 or val [0] is None : narcisse.narsetar ( "theta" , -45.0 ) else : narcisse.narsetar ( "theta" , val [0] ) narcisse.narsetvals ( self._file_descr ) def set_roll ( self , * val ) : """set_roll (arg) is the angle of rotation around the line determined by set_phi and set_theta. If called with no argument, roll is set to zero degrees. Otherwise it should be called with an integer argument (the angle in degrees).""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 or val [0] is None : narcisse.narsetar ( "roll" , 0.0 ) else : narcisse.narsetar ( "roll" , val [0] ) narcisse.narsetvals ( self._file_descr ) def set_gnomon (self, val) : """set_gnomon (val) does nothing in Narcisse.""" return # set the distance of view def set_distance ( self , * val ) : """set_distance (arg) sets the distance of the view point from a 3d graph. If called with no argument, or 0.0, this distance is effectively infinite. Otherwise it should be called with a real number.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( val ) == 0 : narcisse.narsetar ( "distance" , 0. ) else : narcisse.narsetar ( "distance" , val [0] ) narcisse.narsetvals ( self._file_descr ) # set whether a curve is drawn as a line, step, or one of a set # of symbols. val1 specifies the curve(s) and val2 the type(s). # If they're both scalars, set that one curve. If they are both # vectors, the shorter length will be used. If val1 is a vector # and val2 a scalar, then set all curves to the same type. # Note: narsetvals has to be called after each call to one of # the indexed routines, or else only the last one set is effective. # Bug or feature? I don't know. ###################NOTE: # Currently val2 is an integer value. Eventually I want to replace # it with a character designation. ################### def set_curve_type ( self , val1 , val2 ) : """set_curve_type (arg1, arg2) is used to determine how one or a family of curves is to be plotted. It must be called with two arguments. The first argument is an integer scalar or array Int giving the curve number(s) and the second is an integer scalar or array Int describing how the curve(s) should be graphed. Curves are numbered starting with 0. The allowed values for the second argument are: -1 (do not graph), 0 (normal graph), 1 (graph as a step function), or else a number of options to draw the graph as a set of points denoted by symbols: 2 (+), 3 (*), 4 (o) , 5 (x) , 6 (.).""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if type (val1) == IntType and type (val2) == IntType : narcisse.narsetaii ( "curve_type" , val2 , val1 ) narcisse.narsetvals ( self._file_descr ) elif type (val1) == ArrayType and val1.dtype == Int \ and type (val2) == IntType : for i in range (len (val2)) : narcisse.narsetaii ( "curve_type" , val2 , val1 [i] ) narcisse.narsetvals ( self._file_descr ) elif not is_scalar (val1) and not is_scalar (val2) : # both must be > 1 in length r = range (len (val1)) if len (val2) < len (val1) : r = range (len (val2)) for i in r : narcisse.narsetaii ( "curve_type" , val2 [i] , val1 [i] ) narcisse.narsetvals ( self._file_descr ) else : raise self.NarError, "bad arguments to curve_type." # set the curve color(s) for one or a set of curves. # val1 specifies the curve(s) and val2 the color(s). # If they're both scalars, set that one curve. If they are both # vectors, the shorter length will be used. If val1 is a vector # and val2 a scalar, then set all curves to the same color. ###################NOTE: # Currently val2 is an integer value. Eventually I want to replace # it with a character designation. ################### def set_curve_color ( self , val1 , val2 ) : """set_curve_color (arg1, arg2) is used to determine how one or a family of curves is to be colored. It must be called with two arguments. The first argument is an integer scalar or array Int giving the curve number(s) and the second is an integer scalar or array Int describing how the curve(s) should be colored. Curves are numbered starting with 0. The allowed values for the second argument are 0 to 63, denoting the index into the current palette.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if is_scalar (val1) and is_scalar (val2) : val2 = self._figure_color (val2) narcisse.narsetaii ( "curve_color" , val2 , val1 ) narcisse.narsetvals ( self._file_descr ) elif not is_scalar (val1) and len (val1) > 1 and is_scalar (val2) : val2 = self._figure_color (val2) for i in range (len (val2)) : narcisse.narsetaii ( "curve_color" , val2 , val1 [i] ) narcisse.narsetvals ( self._file_descr ) elif not is_scalar (val1) and not is_scalar (val2) : # both must be > 1 in length r = range (len (val1)) if len (val2) < len (val1) : r = range (len (val2)) for i in r : val2 [i] = self._figure_color (val2 [i]) narcisse.narsetaii ( "curve_color" , val2 [i] , val1 [i] ) narcisse.narsetvals ( self._file_descr ) else : raise self.NarError , "bad parameters to set_curve_color." # set the label type for the curves. "end" and "box". def set_label_type ( self , val ) : """set_label_type (arg) determines whether curve labels will be attached to the ends of curves, or enclosed in a box. The allowed arguments are thus 'end' and 'box'.""" if ( val == "end" ) : narcisse.narsetai ( "curve_label_type" , 0 ) elif val == "box" : narcisse.narsetai ( "curve_label_type" , 1 ) else : raise self.NarError ,\ "set_label_type: 'end' and 'box' are the allowed options." # set the curve label(s) for one or a set of curves. # val1 specifies the curve(s) and val2 the label(s). # If they're both scalars, set that one curve. If they are both # vectors, choose the shorter of the two lengths. def set_curve_label ( self , val1 , val2 ) : """set_curve_label (arg1, arg2) is used to label one or a set of curves. It requires two arguments. The first is an integer scalar or array specifying the curve numbers (starting with 1). The second is a scalar string or list of strings specifying the label(s) of the curve(s).""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if type (val1) == IntType and type (val2) == StringType : narcisse.narsetaci ( "curve_label" , val2 , val1 ) elif type (val1) == ArrayType and val1.dtype == Int and \ type (val2) == ListType and type (val2 [0]) == StringType : r = range (len (val1)) if len (val2) < len (val1) : r = range (len (val2)) for i in r : narcisse.narsetaci ( "curve_label" , val2 [i] , val1 [i] ) narcisse.narsetvals ( self._file_descr ) else : print "Val1: " , `val1` print "Val2: " , `val2` raise self.NarError ,\ "set_curve_label: arguments have inconsistent types or sizes." def set_xyequal (self) : """set_xyequal () sets a parameter that makes the axes equal scale.""" self._xyequal = 1 def reset_xyequal (self) : """set_xyequal () resets a parameter that makes the axes equal scale.""" self._xyequal = 0 narcisse_marks = { "+" : 2 , "*" : 3 , "o" : 4 , "x" : 5 , "." : 6 } narcisse_types = { "none" : -1 , "hide" : -1 , "line" : 0 , "normal" : 0 , "step" : 1 } def _figure_type ( self , crv ) : """_figure_type (crv) makes sure to return a valid type for a Narcisse curve. """ if crv.hide : return -1 if crv.marks and crv.marker is None : if (type (crv.line_type) == IntType and \ crv.line_type == 0 or \ type (crv.line_type) == StringType and \ (crv.line_type == "line" or crv.line_type == "normal" or \ crv.line_type == "solid")) : if crv.label == " " : crv.label = uppercase [self._next_letter] self._next_letter = (self._next_letter + 1) % 26 return 0 if crv.marks and crv.marker is not None : # if a marker is specified but a curve is desired, set the # curve's label to the marker if type (crv.marker) == StringType and \ (type (crv.line_type) == IntType and \ crv.line_type == 0 or \ type (crv.line_type) == StringType and \ (crv.line_type == "line" or crv.line_type == "normal" or \ crv.line_type == "solid")) : if crv.label == " " : crv.label = crv.marker return 0 if type (crv.marker) == IntType and 2 <= crv.marker <= 6 : return crv.marker if type (crv.marker) == StringType and \ self.narcisse_marks.has_key (crv.marker) : return self.narcisse_marks [crv.marker] if type (crv.line_type) == IntType and -1 <= crv.line_type <= 6 : return crv.line_type if type (crv.line_type) == StringType and \ self.narcisse_types.has_key (crv.line_type) : return self.narcisse_types [crv.line_type] return 0 # incomprehensible so draw a line def plot_object ( self , crv ) : """plot_object (crv) is a general purpose plotting routine. It should be called with one argument, a curve (all that Narcisse currently accepts). In the case of multiple objects on one graph, the first call only should be to this routine, subsequent calls to add_object. For Narcisse, plot_object and add_object accumulate information about the various curves, then send all the freight when send_graph is called. """ try : dum = crv.type () except : raise self.NarError , \ "Unknown object has been sent to Narcisse." if dum != CurveType : raise self.NarError , \ "Narcisse does not know how to graph a " + dum + "." if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." self._graph_type = 2 # We compute new axis limits if user wants equal scales if self._xyequal : new_x_limits = minmax (crv.x) new_y_limits = minmax (crv.y) self._x_axis_min = new_x_limits [0] self._x_axis_max = new_x_limits [1] self._y_axis_min = new_y_limits [0] self._y_axis_max = new_y_limits [1] # start a list of attributes for curves self._types = [self._figure_type (crv)] self._labels = [crv.label] self._colors = [crv.color] self._axispref = [crv.axis] self._ylist = [crv.y] self._xlist = [crv.x] # add a curve to an existing plot def add_object ( self , crv ) : """add_object (crv) will add a curve to an existing graph. The curve's attributes are saved up; nothing is sent to Narcisse until send_graph is called. """ try : dum = crv.type () except : raise self.NarError , \ "Unknown object has been sent to Narcisse." if dum != CurveType : raise self.NarError , \ "Narcisse does not know how to graph a " + dum + "." if self._graph_type != 2 : raise self.NarError , \ "plot_object must be called for the first curve on a graph." if self._xyequal : new_x_limits = minmax (crv.x) new_y_limits = minmax (crv.y) if self._x_axis_min > new_x_limits [0] : self._x_axis_min = new_x_limits [0] if self._x_axis_max < new_x_limits [1] : self._x_axis_max = new_x_limits [1] if self._y_axis_min > new_y_limits [0] : self._y_axis_min = new_y_limits [0] if self._y_axis_max < new_y_limits [1] : self._y_axis_max = new_y_limits [1] self._types.append (self._figure_type (crv)) self._labels.append (crv.label) self._colors.append (crv.color) self._ylist.append (crv.y) self._xlist.append (crv.x) self._axispref.append (crv.axis) def _send_2d_info ( self ) : """_send_2d_info ( ) sends the accumulated curve information out to Narcisse. """ n = len (self._ylist) if n <= 0 : raise self.NarError, \ "There is nothing to graph!" elif n == 1 : arg1 = 0 arg2t = self._types [0] arg2c = self._colors [0] arg2l = self._labels [0] else : arg1 = arange (n, dtype = Int) arg2t = self._types arg2c = self._colors arg2l = self._labels y = self._ylist [0].astype (NarFloat) x = self._xlist [0].astype (NarFloat) narcisse.nar1curve (self._file_descr, y, x) self.set_y_axis (0, self._axispref [0]) for i in range (1, n) : y = self._ylist [i].astype (NarFloat) x = self._xlist [i].astype (NarFloat) narcisse.narsetai ( "option_2d_concatenate" , 1 ) narcisse.narsetvals ( self._file_descr ) narcisse.nar1curve (self._file_descr, y, x) narcisse.narsetai ( "option_2d_concatenate" , 0 ) narcisse.narsetvals ( self._file_descr ) self.set_y_axis (i, self._axispref [i]) self.set_curve_type (arg1, arg2t) self.set_curve_color (arg1, arg2c) self.set_curve_label (arg1, arg2l) def plot_text ( self ) : "plot_text does nothing in Narcisse." return def set_text ( self , txt , n ) : "set_text (str, ix) sets the ix'th text to str." if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if txt == " " : txt = "" narcisse.narsetaci ( "text_value" , txt , n ) narcisse.narsetvals ( self._file_descr ) def clear_text (self) : "clear_text ( ) sets the number of texts to 0." if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." narcisse.narsetaci ( "text_value" , "" , 0 ) narcisse.narsetai ( "text_number" , 0 ) narcisse.narsetvals ( self._file_descr ) def set_text_color ( self , txt , n ) : """set_text_color (col, ix) sets the ix'th text color to col, which is a number between 0 and 63 associated with a color table.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." txt = self._figure_color (txt) narcisse.narsetaii ( "text_color" , txt , n ) narcisse.narsetvals ( self._file_descr ) def set_text_size ( self , txt , n ) : """set_text_size (sz, ix) sets the ix'th text size to sz. sz represents essentially the number of characters that will fill the width of the graphics screen, so the larger the number, the smaller the text.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." narcisse.narsetaii ( "text_size" , txt , n ) narcisse.narsetvals ( self._file_descr ) def set_text_pos ( self , x , y , ix ) : """set_text_pos (x, y, ix) positions the ix'th text at (x, y), which are real numbers between 0 and 1 giving relative position in the graphics window.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." narcisse.narsetari ("text_pos_x", x, ix) narcisse.narsetari ("text_pos_y", y, ix) narcisse.narsetvals ( self._file_descr ) # Here's the grandaddy of them all, a perfectly general surface # plotting routine. Note that it passes a lot of information # to narcissemodule for error checking. ############################################################### # Eventually these routines should probably all be rewritten # to accept numerical sequences of any kind as inputs, # convert them to array types as appropriate, check for # appropriate dimensions, etc. The problem is that anybody # can call the low level routines directly from Python, so they # need to do error checking anyhow, just in case. ############################################################### def plot_surface ( self , arg1 , * args2 ) : """plot_surface (args) is a general-purpose 3d/4d plotting routine. The type of plot depends on the numbers and types of the arguments (which all must be of type array NarFloat except for the cell information for unstructured grids). Here we go: 1. single argument, two dimensional array z: Plot z as a surface versus equally spaced x and y coordinates. 2. three arguments, two vectors x and y and a two dimensional matrix z: plot z as a surface versus the given x and y. 3. three arguments, matrices x, y, and z (whose dimensions must match): plot z as a surface versus the given x and y. 4. four arguments, two vectors x and y and two two dimensional matrices z and c: plot z as a surface versus the given x and y; use the variable c to color the graph. 5. four arguments, matrices x, y, z, and c (whose dimensions must match): plot z as a surface versus the given x and y; use the variable c to color the graph. 6. four arguments, three vectors x, y, and z specifying a structured grid, and a three-dimensional array c defined at each grid point: draw the grid and color according to the variable c. 7. six arguments, vectors x, y, and z of the same size specifying a nonstructured grid, and c of the same size specifying a value at each point; cd, an integer vector specifying connectivity (see the Narcisse manual for details), and nc an integer specifying the number of cells in the grid, draw the nonstructured grid and color according to the variable c.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if len ( args2 ) == 0 : narcisse.narsurf ( self._file_descr , arg1.astype (NarFloat) ) return if len ( args2 ) == 2 or len ( args2 ) > 2 and args2 [2] is None : x = arg1.astype (NarFloat) y = args2 [0].astype (NarFloat) z = args2 [1].astype (NarFloat) if len (x.shape) == 1 and len (y.shape) == 1 : narcisse.nar3drect ( self._file_descr , x , y , z ) return else : narcisse.nar3dtetra ( self._file_descr , x , y , z ) return if len ( args2 ) == 3 : x = arg1.astype (NarFloat) y = args2 [0].astype (NarFloat) z = args2 [1].astype (NarFloat) c = args2 [2].astype (NarFloat) if ( len ( z.shape ) == 2 ) : if len ( x.shape ) == 1 : narcisse.nar4drect ( self._file_descr , x , y , z , c ) return else : narcisse.nar4dtetra ( self._file_descr , x , y , z , c ) return else : narcisse.narstructmesh ( self._file_descr , x , y , z , c ) return if len ( args2 ) == 5 : x = arg1.astype (NarFloat) y = args2 [0].astype (NarFloat) z = args2 [1].astype (NarFloat) c = args2 [2].astype (NarFloat) cd = args2 [3].astype (Int) nc = args2 [4] narcisse.narnonstructmesh ( self._file_descr , x , y , z , c , cd , nc) return else : n=1+len (args2) raise self.NarError ,\ "plot_surface: inappropriate number of arguments: " + `n` def set_palette (self, col) : """set_palette (col) sets the color palette to col. The first entry in col tells how long the rest of the array is; then there are col [0] / 3 entries for red, followed by the same number of greens, followed by the same number of blues. """ for i in range (col [0]) : narcisse.narsetaii ("parameter_map_pal", col [i + 1], i) narcisse.narsetai ("parameter_map", -1) narcisse.narsetvals ( self._file_descr ) def set_no_concat ( self ) : #called by a graphics object initially "set_no_concat () turns off the 2d and 3d concatenation mode." narcisse.narsetai ("option_3d_concatenate", 0) narcisse.narsetai ("option_2d_concatenate", 0) narcisse.narsetvals ( self._file_descr ) # add a surface to an existing plot def add_surface ( self , arg1 , * args2 ) : """add_surface (args) will add one or more surfaces to an existing graph. Its arguments are the same form as the arguments of plot_surface. See plot_surface documentation for details.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." narcisse.narsetai ("option_3d_concatenate" , 1 ) narcisse.narsetvals ( self._file_descr ) if len (args2) == 0 : self.plot_surface ( arg1 ) elif len (args2) == 2 : self.plot_surface ( arg1 , args2 [0] , args2 [1] ) elif len (args2) == 3 : self.plot_surface ( arg1 , args2 [0] , args2 [1] , args2 [2] ) elif len (args2) == 5 : self.plot_surface ( arg1 , args2 [0] , args2 [1] , args2 [2] , args2 [3] , args2 [4] ) else : raise self.NarError , "add_surface: inappropriate number of arguments ("\ + `len (args2)` + ")." narcisse.narsetai ("option_3d_concatenate" , 0 ) narcisse.narsetvals ( self._file_descr ) # routine to freeze the graph # i. e., arguments and graphs sent will not be plotted until # send_graph is called. def freeze_graph ( self ) : """freeze_graph () keeps a graph from being plotted until send_graph () is called.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if not self._frozen : narcisse.narsetai ( "plot_now" , 0 ) narcisse.narsetvals ( self._file_descr ) self._frozen = 1 # routine to release the graph # The current graph will be plotted and any arguments will # be sent. if _freeze_each has been set, then the next graph # will be _frozen too. def send_graph ( self, graf ) : """send_graph () causes a plot that has been accumulated after freeze_graph () was called, to be plotted.""" if not self._file_open : raise self.ConnectException , \ "You are not connected to Narcisse." if self._graph_type == 0 : raise self.NarError, \ "There is nothing to graph!" if graf.type () == Graph3dType : self._dims = 3 else : self.dims = 2 self._send_axes_limits ( ) if self._graph_type == 2 : self._send_2d_info ( ) if self._frozen : self._frozen = 0 narcisse.narsetai ( "plot_now" , 1 ) narcisse.narsetvals ( self._file_descr ) if self._freeze_each : self.freeze_graph ( ) def set_freeze_each ( self , val ) : """set_freeze_each ( fe ) tells whether or not to re-freeze the graphics after each send_graph call. 1 to re-freeze, 0 not to.""" self._freeze_each = val def send_generics (self, graf) : """send_generics ( graf ) sets up all the things that are generic to any graph. It does not actually do any plotting yet. """ self.set_titles ( graf._titles ) self.set_title_colors ( graf._title_colors ) # The following line is redundant for Gist. Not sure about Narcisse. # self._plot_titles ( ) self.set_grid_type ( graf._grid_type ) self.clear_text ( ) if is_scalar ( graf._text ) : if ( graf._text != "" and graf._text != " ") : self.set_text ( graf._text , 0 ) else : for i in range ( len ( graf._text ) ) : self.set_text ( graf._text [i] , i ) if is_scalar ( graf._text_color ) : self.set_text_color ( graf._text_color , 0 ) else : for i in range ( len ( graf._text_color ) ) : self.set_text_color ( graf._text_color [i] , i ) if is_scalar ( graf._text_size ) : self.set_text_size ( graf._text_size , 0 ) else : for i in range ( len ( graf._text_size ) ) : self.set_text_size ( graf._text_size [i] , i ) if is_scalar ( graf._tosys ) : self.set_tosys ( graf._tosys , 0 ) else : for i in range ( len ( graf._tosys ) ) : self.set_tosys ( graf._tosys [i] , i ) if is_scalar ( graf._text_pos ) : raise graf._GraphSpecError , \ "Text position must be a point or an array of points." if len ( shape ( graf._text_pos )) == 1: self.set_text_pos ( graf._text_pos [0] , graf._text_pos [1] , 0 ) else : for i in range (shape (graf._text_pos) [0] ) : self.set_text_pos ( graf._text_pos [i][0] , graf._text_pos [i][1] , i ) # The following is the equivalent of the Gist split palette. # The lower half is the rainbow, the upper half is greyscale. split_palette = array ([162, # The last 54 colors of the palette #27 reds, 27 greys: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 67, 115, 163, 211, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 9, 19, 29, 39, 49, 58, 68, 78, 88, 98, 107, 117, 127, 137, 147, 156, 166, 176, 186, 196, 205, 215, 225, 235, 245, 255, #27, greens, 27 greys: 24, 72, 120, 168, 216, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 226, 178, 129, 81, 33, 0, 0, 0, 0, 0, 0, 0, 9, 19, 29, 39, 49, 58, 68, 78, 88, 98, 107, 117, 127, 137, 147, 156, 166, 176, 186, 196, 205, 215, 225, 235, 245, 255, #27 blues, 27 greys: 255, 255, 255, 255, 255, 245, 197, 149, 101, 52, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 62, 110, 158, 206, 255, 0, 9, 19, 29, 39, 49, 58, 68, 78, 88, 98, 107, 117, 127, 137, 147, 156, 166, 176, 186, 196, 205, 215, 225, 235, 245, 255 ], Int) def do_generic (self, graf) : self.set_freeze_each (1) self.freeze_graph ( ) #freeze everything until entire graph is sent self.set_no_concat ( ) self.send_generics ( graf ) self.set_axis_labels ( graf._axis_labels ) self.set_x_axis_limits (graf._axis_limits [0][0], graf._axis_limits [0][1]) self.set_y_axis_limits (graf._axis_limits [1][0], graf._axis_limits [1][1]) if self._dims == 2 : self.set_yr_axis_limits (graf._axis_limits [2][0], graf._axis_limits [2][1]) elif self._dims == 3 : self.set_z_axis_limits (graf._axis_limits [2][0], graf._axis_limits [2][1]) self.set_c_axis_limits (graf._axis_limits [3][0], graf._axis_limits [3][1]) self.set_yr_axis_limits (graf._axis_limits [4][0], graf._axis_limits [4][1]) if self._dims == 2: for i in range (graf._no_of_axes) : if graf._axis_scales [i] == "lin" : self.set_axis_lin (graf._axes [i]) elif graf._axis_scales [i] == "log" : self.set_axis_log (graf._axes [i]) else : raise graf._AxisSpecError , \ graf._axis_scales [i] + " is not a valid axis scale." elif self._dims == 3: sc = graf._axis_scales if is_scalar (sc) : sc = [sc] + ["lin", "lin", "lin", "lin"] else : for i in range (5 - no_of_dims (sc)) : sc = sc + ["lin"] for i in range (5) : if sc [i] == "log" : self.set_axis_log (graf._axes [i]) else : # anything else will be lin self.set_axis_lin (graf._axes [i]) try: no_color = os.environ["NO_COLOR"] except KeyError: no_color = 0 if no_color == 0 or no_color == "no" or no_color == "n" : self.set_color_card (graf._color_card , 1) if self._dims == 3: self.set_phi ( graf._phi ) self.set_theta ( graf._theta ) self.set_roll ( graf._roll ) return def quick_plot (self, graf) : "quick_plot (graf) plots without recomputing." if graf.type () == Graph2dType : self._dims = 2 else : self._dims = 3 self.do_generic (graf) if hasattr (graf, "n") and self._dims == 3 : if graf.opt_3d_change : self.set_3d_options ( graf._color_bar, graf._color_bar_pos, graf._s [graf.n - 1].opt_3d ) if graf.mask_change : self.set_mask ( graf._s [graf.n - 1].mask ) if graf.mesh_type_change : self.set_3d_grid_type ( graf._s [graf.n - 1].mesh_type ) if hasattr (graf, "n") and self._dims == 2 : if graf.type_change : self.set_curve_type ( graf.n - 1 , graf._c[graf.n - 1].line_type ) if graf.color_change : self.set_curve_color ( graf.n - 1 , graf._c[graf.n - 1].color ) if graf.label_change : self.set_curve_label ( graf.n - 1 , graf._c[graf.n - 1].label ) if graf._label_type != " " : self.set_label_type ( graf._label_type ) if (graf._sync) : self.synchronize ( ) self.send_graph (graf) def plot2d (self, graf) : """A Graph2d object calls plot2d with itself as argument. plot2d sorts out everything for the graph and then does the plot. The bulk of this work used to be done in Graph and Graph2d, but I decided it was too graphics-dependent. """ self._dims = 2 # (1) Do graph-generic stuff first self.do_generic (graf) # (2) Do the specifically 2d stuff sc = graf._axis_scales if graf._xyequal : self.set_xyequal ( ) else : self.reset_xyequal ( ) if is_scalar (sc) : if sc == "linlin" or sc == "lin" : self.set_linlin ( ) elif sc == "linlog" : self.set_linlog ( ) elif sc == "loglin" or sc == "log" : self.set_loglin ( ) elif sc == "loglog" : self.set_loglog ( ) else : if len (sc) == 1 : sc = sc + ["lin", "lin"] elif len (sc) == 2 : sc = sc + ["lin"] for n in range (3) : if sc [n] == "log" : self.set_axis_log (graf._axes [n]) else : self.set_axis_lin (graf._axes [n]) for i in range ( graf._c_ln ) : if i == 0 : self.plot_object ( graf._c [i] ) else : self.add_object ( graf._c [i] ) self.plot_text ( ) # Finally do the graph if (graf._sync) : self.synchronize ( ) self.send_graph (graf) def split_bytscl (self, val, top) : """ split_bytscl (val, top) scales the values in val to the top half of the palette (values 27 to 53) if top = 1, and to the bottom half (values 0 to 26) if top = 0. """ retval = ( (val - min (val)).astype(Float) / max( (val - min (val)).astype(Float)*26. + 0.5)).astype (Int) + top * 26 def plot3d (self, graf) : """plot3d (graf) plots a 3d graph object. """ self._dims = 3 # (1) Do graph-generic stuff first self.do_generic (graf) self.set_phi ( graf._phi ) self.set_theta ( graf._theta ) self.set_roll ( graf._roll ) self.set_distance ( graf._distance ) n = graf._s_ln if n > 1 and graf._connect : self.set_connect ( 1) else : self.set_connect ( 0) if graf._s [0].type () == Slice3dType : # This is a graph of one or more isosurface and/or plane slices. # Basically, we just need to put the vertices and cell # information into the form recognized by SpxNonStruct4d. # For now, Narcisse will not allow slices to be combined # with other surfaces. # send out surface characteristics, then each surface self.set_link ( 0 ) self.set_mask ( graf.mask ) self.set_3d_options ( graf._color_bar, graf._color_bar_pos, graf._s [0].opt_3d ) self.set_3d_grid_type ( graf._s[0].mesh_type ) self.set_z_c_switch ( graf._s[0].z_c_switch ) self.set_z_contours ( graf._s[0].z_contours_scale ) self.set_c_contours ( graf._s[0].c_contours_scale ) if graf._s[0].z_contours_array is None : if graf._s[0].number_of_z_contours is None : self.set_z_contours (20) else : self.set_z_contours (graf._s[0].number_of_z_contours) else : self.set_z_contours ( graf._s[0].z_contours_array ) if graf._s[0].c_contours_array is None : if graf._s[0].number_of_c_contours is None : self.set_c_contours (20) else : self.set_c_contours (graf._s[0].number_of_c_contours) else : self.set_c_contours ( graf._s[0].c_contours_array ) isosurfaces_present = 0 self._graph_type = 4 for i in range (graf._s_ln) : if graf._s [i].type () == Slice3dType : if graf._s [i].plane is None and graf._s [i].iso is not None : isosurfaces_present = 1 else : raise self.NarError, \ "If one component is a Slice, all must be." for i in range (graf._s_ln) : s = graf._s [i] opt_3d = s.opt_3d if type (opt_3d) != ListType : opt_3d = [opt_3d] if i == 0 : nv = s.nv x = s.xyzv [:, 0] y = s.xyzv [:, 1] z = s.xyzv [:, 2] if (max (abs (x)) < 10.e-30) : x [0: len(x)] = 0. if (max (abs (y)) < 10.e-30) : y [0: len(y)] = 0. if (max (abs (z)) < 10.e-30) : z [0: len(z)] = 0. if not isosurfaces_present or s.iso is None and \ s.plane is None : if "i3" in opt_3d or "s3" in opt_3d or \ "w3" in opt_3d or "f3" in opt_3d : val = z else : val = s.val elif s.plane is not None : if len(s.val) == len (s.nv) : val = to_corners (s.val, s.nv, sum (s.nv,axis=0)) else : val = s.val else : val = ones (sum (s.nv,axis=0), Float) * s.iso else : nv = concatenate ( (nv, s.nv)) x = concatenate ( (x, s.xyzv [:, 0])) y = concatenate ( (y, s.xyzv [:, 1])) z = concatenate ( (z, s.xyzv [:, 2])) if not isosurfaces_present or s.iso is None and \ s.plane is None : val = concatenate ( (val, s.val)) elif s.plane is not None : if len(s.val) == len (s.nv) : val = concatenate ( (val, to_corners (s.val, s.nv, sum (s.nv,axis=0)))) else : val = concatenate ( (val, s.val)) else : val = concatenate ( (val, ones (sum (s.nv,axis=0), Float) * s.iso)) nc = len (nv) nv = concatenate ( (cumsum (nv,axis=0), arange (len (x)))) ## if isosurfaces_present : ## self.set_palette (self.split_palette) self.set_color_card (graf._color_card) self.plot_surface (x, y, z, val, nv, nc) if (graf._sync) : self.synchronize ( ) self.plot_text ( ) self.send_graph (graf) elif graf._link : # got to send out one surface and its characteristics at a time self.set_link ( 1 ) for i in range ( n ) : # Do not replot axes for subsequent components if i > 0 : self.set_grid_type ("none") self.set_mask ( graf._s[i].mask ) self.set_3d_options ( graf._color_bar, graf._color_bar_pos, graf._s[i].opt_3d ) self.set_3d_grid_type ( graf._s[i].mesh_type ) if graf._s[i].z_c_switch : self.set_z_c_switch ( 1 ) else : self.set_z_c_switch ( 0 ) self.set_z_contours ( graf._s[i].z_contours_scale ) self.set_c_contours ( graf._s[i].c_contours_scale ) if graf._s[i].z_contours_array is None : if graf._s[i].number_of_z_contours is None : self.set_z_contours (20) else : self.set_z_contours (graf._s[i].number_of_z_contours) else : self.set_z_contours ( graf._s[i].z_contours_array ) if graf._s[i].c_contours_array is None : if graf._s[i].number_of_c_contours is None : self.set_c_contours (20) else : self.set_c_contours (graf._s[i].number_of_c_contours) else : self.set_c_contours ( graf._s[i].c_contours_array ) # always send coordinates of linked surfaces if not hasattr (graf._s[i], "x") or \ graf._s[i].x is None : # just graphing z self._graph_type = 3 self.plot_surface ( array ( graf._s[i].z, Float)) elif graf._s[i].c is None : #surface alone self._graph_type = 3 self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float)) else : # 4d plot (surface or structured mesh plot) self._graph_type = 4 if graf._s[i].type () == SurfaceType or \ graf._s[i].structured : # (surface or structured mesh plot) self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float)) else : # Nonstructured mesh graf._s[i].create_Narcisse_format () self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float), array ( graf._s[i].cell_descr, Int ), graf._s[i].number_of_cells) if (graf._sync) : self.synchronize ( ) self.send_graph (graf) if i == 0 : self.plot_text ( ) self.set_link (0) else : # not graf._link # send out surface characteristics, then each surface self.set_link ( 0 ) self.set_mask ( graf._s[n - 1].mask ) self.set_3d_options ( graf._color_bar, graf._color_bar_pos, graf._s[n - 1].opt_3d ) self.set_3d_grid_type ( graf._s[n - 1].mesh_type ) self.set_z_c_switch ( graf._s[n - 1].z_c_switch ) self.set_z_contours ( graf._s[n - 1].z_contours_scale ) self.set_c_contours ( graf._s[n - 1].c_contours_scale ) if graf._s[n - 1].z_contours_array is None : if graf._s[n - 1].number_of_z_contours is None : self.set_z_contours (20) else : self.set_z_contours (graf._s[n - 1].number_of_z_contours) else : self.set_z_contours ( graf._s[n - 1].z_contours_array ) if graf._s[n - 1].c_contours_array is None : if graf._s[n - 1].number_of_c_contours is None : self.set_c_contours (20) else : self.set_c_contours (graf._s[n - 1].number_of_c_contours) else : self.set_c_contours ( graf._s[n - 1].c_contours_array ) if graf._send_coordinates : for i in range ( n ) : # now send out surfaces if not hasattr (graf._s[i], "x") or \ graf._s[i].x is None : # just graphing z self._graph_type = 3 if i == 0 : self.plot_surface (array (graf._s[i].z, Float)) else : self.add_surface (array (graf._s[i].z, Float)) elif graf._s[i].c is None : # 3d plot self._graph_type = 3 if i == 0 : self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float)) else : self.add_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float)) else : # 4d plot (surface or structured mesh plot) self._graph_type = 4 if graf._s[i].type () == SurfaceType or \ graf._s[i].structured : if i == 0 : self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float)) else : self.add_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float)) else : # Nonstructured mesh plot graf._s[i].create_Narcisse_format () if i == 0 : self.plot_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float), array ( graf._s[i].cell_descr, Int), graf._s[i].number_of_cells ) else : self.add_surface ( array ( graf._s[i].x, Float), array ( graf._s[i].y, Float), array ( graf._s[i].z, Float), array ( graf._s[i].c, Float), array ( graf._s[i].cell_descr, Int), graf._s[i].number_of_cells ) if (graf._sync) : self.synchronize ( ) self.plot_text ( ) self.send_graph (graf) def move_light_source (self, graf, angle, nframes) : raise self.NarError, \ "Sorry, Narcisse does not yet support a moving light source." def rotate_graph (self, axis, angle, nframes) : # In Narcisse, only the angle counts. narcisse.narsetai ("animation_number", nframes) angle = angle * 180. / pi narcisse.narsetai ("animation_azimuth", angle) narcisse.narsetai ("animation_elevation", angle) if self._frozen : self._frozen = 0 narcisse.narsetai ( "plot_now" , 1 ) narcisse.narsetvals ( self._file_descr ) if self._freeze_each : self.freeze_graph ( )