gphys 1.1.1 → 1.2.2

data/lib/numru/ggraph.rb

@@ -1,8 +1,8 @@
+# -*- coding: cp932 -*-
 require "numru/gphys"
-require "numru/dcl"
 require "numru/misc"
 require "date"
-require "numru/dclext_datetime_ax"
+require "numru/dclext"
 
 ############################################################
 
@@ -94,66 +94,6 @@ require "numru/dclext_datetime_ax"
     is effective only for the next call of ((<tone>)).
   * ((<vector>)) 2-D vector plot using DCL_Ext::((<flow_vect>))
 
-* ((<module NumRu::DCLExt>))
-  * ((<gl_set_params>))
-    Calls (({DCL.glpset})) multiple times (for each key and val of (({hash}))).
-  * ((<sg_set_params>))
-    Calls (({DCL.sgpset})) multiple times (for each key and val of (({hash}))).
-  * ((<sl_set_params>))
-    Calls (({DCL.slpset})) multiple times (for each key and val of (({hash}))).
-  * ((<sw_set_params>))
-    Calls (({DCL.swpset})) multiple times (for each key and val of (({hash}))).
-  * ((<uz_set_params>))
-    Calls (({DCL.uzpset})) multiple times (for each key and val of (({hash}))).
-  * ((<ul_set_params>))
-    Calls (({DCL.ulpset})) multiple times (for each key and val of (({hash}))).
-  * ((<uc_set_params>))
-    Calls (({DCL.ucpset})) multiple times (for each key and val of (({hash}))).
-  * ((<uu_set_params>))
-    Calls (({DCL.uupset})) multiple times (for each key and val of (({hash}))).
-  * ((<us_set_params>))
-    Calls (({DCL.uspset})) multiple times (for each key and val of (({hash}))).
-  * ((<ud_set_params>))
-    Calls (({DCL.udpset})) multiple times (for each key and val of (({hash}))).
-  * ((<ud_set_linear_levs>))
-    Set contour levels with a constant interval
-  * ((<ud_set_contour>))
-    Set contours of at specified levels.
-  * ((<ud_add_contour>))
-    Same as ((<ud_set_contour>)), but does not clear the contour levels that have
-    been set.
-  * ((<ue_set_params>))
-    Calls (({DCL.uepset})) multiple times (for each key and val of (({hash}))).
-  * ((<ue_set_linear_levs>))
-    Set tone levels with a constant interval
-  * ((<ue_set_tone>))
-    Set tone levels and patterns.
-  * ((<ue_add_tone>))
-    Same as ((<ue_set_tone>)), but does not clear the tone levels that have
-    been set.
-  * ((<ug_set_params>))
-    Calls (({DCL.ugpset})) multiple times (for each key and val of (({hash}))).
-    See ((<gl_set_params>)) for usage.
-  * ((<um_set_params>))
-    Calls (({DCL.umpset})) multiple times (for each key and val of (({hash}))).
-  * ((<lon_ax>))
-    Draw longitude axis. (label format: degrees + 'E' or 'W')
-  * ((<lat_ax>))
-    Draw latitude axis. (label format: degrees + 'N' or 'S')
-  * ((<unit_vect>)) Show the "unit vector", which indicate the vector scaling.
-  * ((<set_unit_vect_options>))
-    Change the default option values for ((<unit_vect>)).
-  * ((<next_unit_vect_options>))
-    Set the option values effective only in the next call of ((<unit_vect>))
-  * ((<flow_vect>)) 2D Vector plot. Unlike (({DCL::ugvect})), scaling are made in term of the physical (or "U") coordinate.
-  * ((<flow_itr5>)) 2D Vector plot on the 2-dim polar coodinate.
-  * ((<color_bar>)) Color Bar
-  * ((<legend>)) 
-    Annotates line/mark type and index (and size if mark).
-  * ((<quasi_log_levels_z>)) 
-    Driver of quasi_log_levels with data values
-  * ((<quasi_log_levels>)) 
-    Returns approximately log-scaled contour/tone levels.
 =module NumRu::GGraph
 
 A graphic library for GPhys using RubyDCL.
@@ -365,6 +305,12 @@ library if you like.
                              #                 (if nil, internally determined)
        "ylabelint"   nil     # Interval of y axis label
                              #                 (if nil, internally determined)
+       "xloglabelall" false  # Show lavels for all log-level tick marks
+                             # (x-axes) (e.g.,1000,900,800,... inseatd of
+                             # 1000,500,200,...)
+       "yloglabelall" false  # Show lavels for all log-level tick marks
+                             # (y-axes) (e.g.,1000,900,800,... inseatd of
+                             # 1000,500,200,...)
        "xmaplabel"   nil     # If "lon"("lat"), use
                              # DCLExt::lon_ax(DCLExt::lat_ax) to draw xaxes;
                              # otherwise, DCL::usxaxs is used.
@@ -1118,2175 +1064,11 @@ library if you like.
        "type"           1    # line type
        "help"       false    # show help message if true
 
-=module NumRu::DCLExt
 
-Collection of various compound DCL functions for convenience.
-This module is to be separated but temporarily included in ggraph.rb
-while it is premature.
-
-==Index
-MATH1
-* ((<glpack>))
-GRPH1
-* ((<sgpack>))
-* ((<slpack>))
-* ((<swpack>))
-GRPH2
-* ((<uzpack>))
-* ((<ulpack>))
-* ((<ucpack>))
-* ((<uupack>))
-* ((<uspack>))
-* ((<udpack>))
-* ((<uepack>))
-* ((<ugpack>))
-* ((<umpack>))
-
-==Module Functions
-
-===glpack
----gl_set_params(hash)
-    Calls (({DCL.glpset})) multiple times (for each key and val of (({hash}))).
-
-    ARGUMENTS
-    * hash (Hash) : combinations of parameter names and values for udpset
-
-    RETURN VALUE
-    * a Hash containing the parameter names and their old values that were
-      replaced.
-
-    EXAMPLES
-    * You can modify parameters temporarily as follows.
-
-        before = DCLExt.gl_set_params({'lmiss'=>true,'rmiss'=>9999.0})
-        ....
-        DCLExt.gl_set_params(before)     # reset the change
-
-===sgpack
----sg_set_params(hash)
-    Calls (({DCL.sgpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===slpack
----sl_set_params(hash)
-    Calls (({DCL.slpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===swpack
----sw_set_params(hash)
-    Calls (({DCL.swpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===uzpack
----uz_set_params(hash)
-    Calls (({DCL.uzpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===ulpack
----ul_set_params(hash)
-    Calls (({DCL.ulpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===ucpack
----uc_set_params(hash)
-    Calls (({DCL.ucpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===uupack
----uu_set_params(hash)
-    Calls (({DCL.uupset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===uspack
----us_set_params(hash)
-    Calls (({DCL.uspset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-===udpack
----ud_set_params(hash)
-    Calls (({DCL.udpset})) multiple times (for each key and val of (({hash}))).
-
-    ARGUMENTS
-    * hash (Hash) : combinations of parameter names and values for udpset
-
-    RETURN VALUE
-    * a Hash containing the parameter names and their old values that were
-      replaced.
-
-    EXAMPLES
-    * You can modify parameters temporarily as follows.
-
-        before = DCLExt.ud_set_params('indxmj'=>4,'lmsg'=>false)
-        DCL.udcntz(data)
-        DCLExt.ud_set_params(before)     # reset the change
-
----ud_set_linear_levs(v, options)
-    Set contour levels with a constant interval
-
-    ARGUMENTS
-    * v : Data values to be fed to udcnt[rz]
-    * options (Hash) : option specification by keys and values. Available
-      options are
-          name   default value   description
-          'min'      nil       minimum contour value (Numeric)
-          'max'      nil       maximum contour value (Numeric)
-          'nlev'     nil       number of levels (Integer)
-          'interval' nil       contour interval (Numeric)
-          'nozero'   nil       delete zero contour (true/false)
-          'coloring' false     set color contours with ud_coloring (true/false)
-          'clr_min'  13        (if coloring) minimum color id (Integer)
-          'clr_max'  99       (if coloring) maximum color id (Integer)
-      Here, (({interval})) has a higher precedence over (({nlev})).
-      Since all the default values are nil, only those explicitly specified
-      are interpreted. If no option is provided, the levels generated will
-      be the default ones set by udcnt[rz] without any level specification.
-
----ud_set_contour(levels,index=nil,line_type=nil,label=nil,label_height=nil)
-    Set contours of at specified levels.
-
-    Normally you do not have to specify (({label})) and (({label_height})).
-
-    It calls DCL.udsclv for each level. So the arguments are basically
-    the same as DCL.udsclv, but only levels are mandatory here.
-
-    ARGUMENTS
-    * levels (Array, NArray, or Numeric) : contour levels to be set.
-      If Numeric, a single level is set.
-    * index (Array of integers, Integer, or nil) :
-      index(es) of the contours. If it is an Array and its length is
-      shorter than that of (({levels})), the same Array is repeated (so
-      for instance [1,1,3] is interpreted as [1,1,3,1,1,3,1,1,3,...]).
-      If it is a single Integer, all the contour will have the same index.
-     If nil, the value of 'indxmn' is used.
-    * line_type (Array of integers, Integer, or nil) :
-      line type(s) of the contours. If it is an Array and its length is
-      shorter than that of (({levels})), the same Array is repeated.
-      the length must agree with that of (({levels})).
-      If it is a single Integer, all the contour will have the same type.
-      If nil, set to be 1.
-    * label (Array of String, String, true, false, nil) :
-      Label(s) of the contours. If it is an Array and its length is
-      shorter than that of (({levels})), the same Array is repeated.
-      the length must agree with that of (({levels})).
-      If  it is a single String, all the contour will have the same label.
-      If true, all the contours will have the labels representing the levels.
-      If false, no label will be drawn (set to "").
-      If nil, same as true for the contours whose index is equal to "INDXMJ",
-      and same as false otherwise.
-    * label_height (Array of Numeric, Numeric, or nil) :
-      Heigh of Labels. Normally you do not have to use this.
-      If it is an Array and its length is
-      shorter than that of (({levels})), the same Array is repeated.
-      If nil, the default value ("RSIZEL") is used for non-empty labels.
-      If a single Numeric, the same value is used for all the contours.
-      Note that it is recommended to not to use this parameter but
-      use DCL.udpset('RZISEL'. label_height), since a positive value
-      here always means to draw labels even when the label is empty.
-
-    RETURN VALUE
-    * nil
-
----ud_add_contour(levels,index=nil,line_type=nil,label=nil,label_height=nil)
-    Same as ((<ud_set_contour>)), but does not clear the contour levels that have
-    been set.
-
-===uepack
----ue_set_params(hash)
-    Calls (({DCL.uepset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
----ue_set_linear_levs(v, options)
-    Set tone levels with a constant interval
-
-    ARGUMENTS
-    * v : Data values to be fed to udcnt[rz]
-    * options (Hash) : option specification by keys and values. Available
-      options are
-          name   default value   description
-          'min'      nil         minimum tone level (Numeric)
-          'max'      nil         maximum tone level (Numeric)
-          'nlev'     nil         number of levels (Integer)
-          'interval' nil         tone-level interval (Numeric)
-      Here, (({interval})) has a higher precedence over (({nlev})).
-      Since all the default values are nil, only those explicitly specified
-      are interpreted. If no option is provided, the levels generated will
-      be the default ones set by udcnt[rz] without any level specification.
-
----ue_set_tone(levels, patterns)
-    Set tone levels and patterns.
-
-    patterns are set between levels as follows:
-
-     when (levels.length == patterns.length+1)
-
-       levels[0]  |  levels[1]  |  levels[2]  ...  |  levels[-2]  |  levels[-1]
-              patterns[0]   patterns[1]   ...  patterns[-2]   patterns[-1]
-
-     when (levels.length == patterns.length)
-
-       levels[0]  |  levels[1]  |  levels[2]  ...  |  levels[-1]  |  +infty
-              patterns[0]   patterns[1]   ...  patterns[-2]   patterns[-1]
-
-     when (levels.length == patterns.length-1)
-
-       -infty  |  levels[0]  |  levels[1]  ...  |  levels[-1]  |  +infty
-           patterns[0]   patterns[1]   ...  patterns[-2]   patterns[-1]
-
-     else
-       error (exception raised)
-
-    ARGUMENTS
-    * levels (Array or NArray of Numeric) : tone levels. Its length must be
-      either 1 larger than, equal to, or 1 smaller than the length of patterns
-    * patterns (Array or NArray of Numeric) : tone patterns
-
-    RETURN VALUE
-    * nil
-
----ue_add_tone(levels, patterns)
-    Same as ((<ue_set_tone>)), but does not clear the tone levels that have
-    been set.
-
-===ugpack
----ug_set_params(hash)
-    Calls (({DCL.ugpset})) multiple times (for each key and val of (({hash}))).
-    See ((<gl_set_params>)) for usage.
-
-===umpack
----um_set_params(hash)
-    Calls (({DCL.umpset})) multiple times (for each key and val of (({hash}))).
-
-    See ((<gl_set_params>)) for usage.
-
-==Original methods:
-
-===Longitude/Latitude Axes
----lon_ax( options=nil )
-
-    Draw longitude axis. (label format: degrees + 'E' or 'W')
-
-    ARGUMENTS
-    * options (Hash) : options to change the default behavior if specified.
-      It is a Hash with option names (String) as keys and their values.
-      Options are interpreted by a NumRu::Misc::KeywordOptAutoHelp,
-      so you can shorten the keys (by omitting tails) as long as it is
-      unambiguous.
-       option name   default value   # description:
-       "yax"         false   # true => draw y-axis, false => draw x-axis
-       "cside"       nil     # "b", "t", "l", "r",
-                             # nil (=>left/bottom), or false (=>right/top)
-       "dtick1"      nil     # Interval of small tickmark
-                             #             (if nil, internally determined)
-       "dtick2"      nil     # Interval of large tickmark with labels
-                             #             (if nil, internally determined)
-
----lat_ax( options=nil )
-
-    Draw latitude axis. (label format: degrees + 'N' or 'S')
-
-    ARGUMENTS
-    * options (Hash) : options to change the default behavior if specified.
-      It is a Hash with option names (String) as keys and their values.
-      Options are interpreted by a NumRu::Misc::KeywordOptAutoHelp,
-      so you can shorten the keys (by omitting tails) as long as it is
-      unambiguous.
-       option name   default value   # description:
-       "xax"         false   # true => draw x-axis, false => draw y-axis
-       "cside"       nil     # "b", "t", "l", "r",
-                             # nil (=>left/bottom), or false (=>right/top)
-       "dtick1"      nil     # Interval of small tickmark
-                             #             (if nil, internally determined)
-       "dtick2"      nil     # Interval of large tickmark with labels
-                             #             (if nil, internally determined)
-
-===Vectors
----unit_vect( vxfxratio, vyfyratio, fxunit=nil, fyunit=nil, options=nil )
-
-    Show the "unit vector", which indicate the vector scaling.
-
-    ARGUMENTS
-    * vxfxratio (Float) : (V cood length)/(actual length) in x
-    * vyfyratio (Float) : (V cood length)/(actual length) in y
-    * fxunit (Float) : If specified, x unit vect len
-    * fyunit (Float) : If specified, y unit vect len
-    * options (Hash) : options to change the default behavior if specified.
-      It is a Hash with option names (String) as keys and their values.
-      Options are interpreted by a NumRu::Misc::KeywordOptAutoHelp,
-      so you can shorten the keys (by omitting tails) as long as it is
-      unambiguous.
-       option name   default value   # description:
-       "vxunit"      0.05    # x unit vect len in V coord. Used only when
-                             # fxunit is omitted (default)
-       "vyunit"      0.05    # y unit vect len in V coord. Used only when
-                             # fyunit is omitted (default)
-       "vxuloc"      nil     # Starting x position of unit vect
-       "vyuloc"      nil     # Starting y position of unit vect
-       "vxuoff"      0.05    # Specify vxuloc by offset from right-bottom
-                             # corner
-       "vyuoff"      0.0     # Specify vyuloc by offset from right-bottom
-                             # corner
-       "inplace"     true    # Whether to print labels right by the unit
-                             # vector (true) or below the x axis (false)
-       "rsizet"      nil     # Label size(default taken from uz-parameter
-                             # 'rsizel1')
-       "index"       3       #  Line index of the unit vector
-       "help"        false   # show help message if true
-
----set_unit_vect_options(options)
-    Change the default option values for ((<unit_vect>)).
-
----next_unit_vect_options(options)
-    Set the option values effective only in the next call of ((<unit_vect>))
-
----flow_vect( fx, fy, factor=1.0, xintv=1, yintv=1)
-
-    2D Vector plot. Unlike (({DCL::ugvect})), scaling are made in term of the physical (or "U") coordinate.
-
-    This method is meant to substitute (({DCL::ugvect})). The scaling
-    is made in terms of the U coordinate. This method is suitable to
-    show vectors such as velocity, since the arrow direction represets
-    the direction in the U coordinate. Also, one can re-scale the
-    vector length easily by using the argument (({factor})).
-
-    Currently, this method is not compatible with map projection,
-    since it calls (({DCL::ugvect})) internally.
-
-    ARGUMENTS
-    * fx, fy (2D NArray or Array) : the vector field.
-    * factor (Integer) : factor to change the arrow length.
-      By default, arrows are scaled so that the longest one
-      match the grid interval.
-    * xintv, yintv (Interger) : interval to thin out (({fx})) and (({fy})),
-      respectively. Useful if the grid points are too many.
-
----flow_itr5( fx, fy, factor=1.0, unit_vect=false )
-
-    2D Vector plot on the polar coodinate.
-
-    This method just perform rotatation of the vector in U-coordinate
-    to N-coordinate and passed to DCL.ugvect.
-
-    ARGUMENTS
-    * fx, fy (2D GPhys) : the vector field.
-    * factor (Integer)  : factor for scaling in ugvect. When it equals 1,
-      vector field will be scaled in DCL.ugvect automatically.
-    * unit_vect()       : Show the unit vector
-
-===Color bars
----set_color_bar_options(options)
-    To set options of ((<color_bar>)) effective in the rest.
-
----color_bar(options=nil)
-    * Descroption:
-      Draws color bars
-
-    * Example
-      Here is the simplest case, where no argument is given to color_bar.
-
-        DCL.uetone(hoge)
-        DCL.usdaxs
-        ...
-        DCL.color_bar
-
-      This draws a color bar by using the levels and tone patterns(colors)
-      set previously. There are many parameters you can set manually,
-      as introduced below:
-
-    * Description of options
-       option name   default value   # description:
-       "levels"      nil     # tone levels (if omitted, latest ones are used)
-       "patterns"    nil     # tone patterns (~colors) (if omitted, latest
-                             # ones are used)
-       "voff"        nil     # how far is the bar from the viewport in the V
-                             # coordinate
-       "vcent"       nil     # center position of the bar in the V coordinate
-                             # (VX or VY)
-       "vlength"     0.3     # bar length in the V coordinate
-       "vwidth"      0.02    # bar width in the V coordinate
-       "inffact"     2.25    # factor to change the length of triangle on the
-                             # side for infinity (relative to 'vwidth')
-       "landscape"   false   # if true, horizonlly long (along x axes)
-       "portrait"    true    # if true, vertically long (along y axes)
-       "top"         false   # place the bar at the top (effective if
-                             # landscape)
-       "left"        false   # place the bar in the left (effective if
-                             # portrait)
-       "units"       nil     # units of the axis of the color bar
-       "units_voff"  0.0     # offset value for units from the default position
-                             # in the V coordinate (only for 'units' != nil)
-       "title"       nil     # title of the color bar
-       "title_voff"  0.0     # offset value for title from the default position
-                             # in the V coordinate (only for 'title' != nil)
-       "tickintv"    1       # 0,1,2,3,.. to specify how frequently the
-                             # dividing tick lines are drawn (0: no tick lines,
-                             # 1: every time, 2: ever other:,...)
-       "labelintv"   nil     # 0,1,2,3,.. to specify how frequently labels are
-                             # drawn (0: no labels, 1: every time, 2: ever
-                             # other:,... default: internally determined)
-       "labels_ud"   nil     # user-defined labels for replacing the default
-                             # labels (Array of String)
-       "charfact"    0.9     # factor to change the label/units/title character
-                             # size (relative to 'rsizel1')
-       "log"         false   # set the color bar scale to logarithmic
-       "constwidth"  false   # if true, each color is drawn with the same width
-       "index"       nil     # line index of tick lines and bar frame
-       "charindex"   nil     # line index of labels, units, and title
-       "chval_fmt"   nil     # string to specify the DCL.chval format for
-                             # labeling
-       "help"        false   # show help message if true
-
-===Others
----legend(str, type, index, line=false, size=nil, vx=nil, dx=nil, vy=nil, first=true, mark_size=nil)
-
-Annotates line/mark type and index (and size if mark).
-By default it is shown in the right margin of the viewport.
-    
-* str is a String to show
-* line: true->line ; false->mark
-* vx: vx of the left-hand point of legend line (or mark position).
-    * nil : internally determined
-    * Float && > 0 : set explicitly
-    * Float && < 0 : move it relatively to the left from the default
-* dx: length of the legend line (not used if mark).
-    * nil : internally determined
-    * Float && > 0 : set explicitly
-* vy: vy of the legend (not used if !first -- see below).
-    * nil : internally determined
-    * Float && > 0 : set explicitly
-    * Float && < 0 : move it relatively lower from the default
-* first : if false, vy is moved lower relatively from the previous vy.
-* mark_size : size of the mark. if nil, size is used.
-
----quasi_log_levels_z(vals, nlev=nil, max=nil, min=nil, cycle=1)
-
-Driver of quasi_log_levels with data values
-
----quasi_log_levels(lev0, lev1, cycle=1)
-
-Returns approximately log-scaled contour/tone levels as well as
-major/minor flags for contours. No DCL call is made in here.
-
-* cycle (Integer; 1, or 2 or 3) : number of level in one-order.
-  e.g. 1,10,100,.. for cycle==1; 1,3,10,30,.. for cycle==2;
-  1,2,5,10,20,50,.. for cycle==3
-* lev0, lev1 (Float) : levels are set between this two params
-  * if lev0 & lev1 > 0 : positive only
-  * if lev0 & lev1 < 0 : negative only
-  * if lev0 * lev1 < 0 : both positive and negative
-    (usig +-[lev0.abs,lev1.abs])
-RETURN VALUE:
-* [ levels, mjmn ]
-
-=end
-############################################################
-
-module NumRu
-
-  module DCLExt
-    # to be included in the RubyDCL distribution
-
-    module_function
-
-    #<<< for many packages >>>
-
-    %w!gl sg sl sw uz ul uc uu us ud ue ug um!.each do |pkg|
-      eval <<-EOS, nil, __FILE__, __LINE__+1
-        def #{pkg}_set_params(hash)
-          before = Hash.new
-          hash.each{|k,v|
-            before[k]=DCL.#{pkg}pget(k)
-            if(v.is_a? String) then
-              DCL.#{pkg}cset(k,v)
-            else
-              DCL.#{pkg}pset(k,v)
-            end
-          }
-          before
-        end
-      EOS
-    end
-
-    #<<< module data >>>
-
-    @@empty_hash = Hash.new
-
-    #<<< udpack >>>
-
-    def ud_coloring(clr_min=13, clr_max=99)
-      # change the colors of existing contours to make a gradation
-      # (rainbow colors with the default color map).
-      nlev = DCL.udqcln
-      cont_params = Array.new
-      for i in 1..nlev
-        cont_params.push( DCL.udqclv(i) )   # => [zlev,indx,ityp,clv,hl]
-      end
-      DCL.udiclv     # clear the contours
-
-      colors = clr_min +
-               NArray.int(nlev).indgen! * (clr_max-clr_min) / nlev
-
-      cont_params.sort!
-      for i in 0...nlev
-        cont_params[i][1] += colors[i]*10   # indx += colors[i]*10
-        DCL.udsclv(*cont_params[i])
-      end
-    end
-
-    def ud_set_linear_levs(v, options=nil)
-      #Accepted options
-      #  name        default  description
-      #  'min'       nil      minimum contour value (Numeric)
-      #  'max'       nil      maximum contour value (Numeric)
-      #  'nlev'      nil      number of levels (Integer)
-      #  'interval'  nil      contour interval (Numeric)
-      #  'nozero'    false    delete zero contour (true/false)
-      #  'coloring'  false    set color contours with ud_coloring (true/false)
-      #  'clr_min'   13       (if coloring) minimum color  number for the
-      #                       maximum data values (Integer)
-      #  'clr_max'   99      (if coloring) maximum color number for the
-      #                       maximum data values (Integer)
-      options = @@empty_hash if !options
-      raise TypeError, "options must be a Hash" if !options.is_a?(Hash)
-      min = options['min']
-      max = options['max']
-      nlev = options['nlev']
-      interval = options['interval']
-      nozero = options['nozero']
-      if interval
-        dx = interval
-      elsif nlev
-        dx = -nlev
-      else
-        dx = 0
-      end
-      if min || max
-        min = v.min if !min
-        max = v.max if !max
-        DCL.udgcla(min, max, dx)
-      else
-        DCL.udgclb(v, dx)
-      end
-      if nozero
-        DCL.uddclv(0.0)
-      end
-      if options['coloring']
-        clr_min = ( options['clr_min'] || 13 )
-        clr_max = ( options['clr_max'] || 99 )
-        ud_coloring( clr_min, clr_max )
-      end
-    end
-
-    def ud_set_contour(*args)
-      DCL.udiclv
-      ud_add_contour(*args)
-    end
-
-    def ud_add_contour(levels,index=nil,line_type=nil,label=nil,label_height=nil)
-
-      # < check levels >
-      case levels
-      when Array, NArray
-        # This is expected. Nothing to do.
-      when Numric
-        levels = [levels]
-      else
-        raise ArgumentError, "invalid level specification (#{levels})"
-      end
-
-      nlev = levels.length
-
-      # < index >
-      index = index.to_a if index.is_a?(NArray)
-      case index
-      when Array
-        raise ArgumentError, "index is an empty array" if index.length == 0
-        while (index.length < nlev )
-          index += index
-        end
-      when Numeric
-        index = [index]*nlev
-      when nil
-        index = [DCL.udpget('indxmn')]*nlev
-      else
-        raise ArgumentError, "unsupported index type (#{index.class})"
-      end
-
-      # < line_type >
-      line_type = line_type.to_a if line_type.is_a?(NArray)
-      case line_type
-      when Array
-        raise ArgumentError, "line_type is an empty array" if line_type.length == 0
-        while (line_type.length < nlev )
-          line_type += line_type
-        end
-      when Numeric
-        line_type = [line_type]*nlev
-      when nil
-        line_type = [1]*nlev
-      else
-        raise ArgumentError, "unsupported index type (#{index.class})"
-      end
-
-      # < label >
-      label = label.to_a if label.is_a?(NArray)
-      case label
-      when Array
-        raise ArgumentError, "label is an empty array" if label.length == 0
-        while (label.length < nlev )
-          label += label
-        end
-      when String
-        label = [label]*nlev
-      when false
-        label = [""]*nlev
-      when true
-        label = (0...nlev).collect{|i|
-            DCL.udlabl(levels[i])
-        }
-      when nil
-        indxmj = DCL.udpget('indxmj')
-        label = (0...nlev).collect{|i|
-          if index[i]==indxmj
-            DCL.udlabl(levels[i])
-          else
-            ""
-          end
-        }
-      else
-        raise ArgumentError, "unsupported index type (#{index.class})"
-      end
-
-      # < label_height >
-      label_height = label_height.to_a if label_height.is_a?(NArray)
-      case label_height
-      when Array
-        raise ArgumentError, "label_height is an empty array" if label_height.length == 0
-        while (label_height.length < nlev )
-          label_height += label_height
-        end
-      when Numeric
-        label_height = [label_height]*nlev
-      when nil
-        label_height = label.collect{|lv| lv=="" ? 0.0 : DCL.udpget('rsizel')}
-      else
-        raise ArgumentError, "unsupported index type (#{index.class})"
-      end
-
-      # < set levels >
-
-      for i in 0...nlev
-        DCL.udsclv(levels[i],index[i],line_type[i],label[i],label_height[i])
-      end
-      nil
-    end
-
-    #<<< uepack >>>
-
-    def ue_set_linear_levs(v, options=nil)
-      #  'min'       nil      minimum tone level (Numeric)
-      #  'max'       nil      maximum tone level (Numeric)
-      #  'nlev'      nil      number of levels (Integer)
-      #  'interval'  nil      tone-level interval (Numeric)
-      options = @@empty_hash if !options
-      raise TypeError, "options must be a Hash" if !options.is_a?(Hash)
-      min = options['min']
-      max = options['max']
-      nlev = options['nlev']
-      interval = options['interval']
-      if interval
-        dx = interval
-      elsif nlev
-        dx = -nlev
-      else
-        dx = 0
-      end
-      if min || max
-        min = v.min if !min
-        max = v.max if !max
-        DCL.uegtla(min, max, dx)
-      else
-        v = v.reshape(v.length,1) if v.rank==1
-        DCL.uegtlb(v, dx)
-      end
-    end
-
-    def ue_set_tone(levels, patterns)
-      DCL.ueitlv
-      ue_add_tone(levels, patterns)
-    end
-
-    def ue_add_tone(levels, patterns)
-
-      # < check types >
-
-      if !levels.is_a?(Array) && !levels.is_a?(NArray)
-        raise TypeError, "levels: Array or NArray expected (#{levels.inspect})"
-      end
-      if !patterns.is_a?(Array) && !patterns.is_a?(NArray)
-        raise TypeError, "patterns: Array or NArray expected (#{patterns.inspect})"
-      end
-
-      # < set levels >
-
-      nlev = levels.length
-      npat = patterns.length
-
-      case (nlev - npat)
-      when 1
-        for i in 0...nlev-1
-          DCL.uestlv(levels[i],levels[i+1],patterns[i])
-        end
-      when 0
-        for i in 0...nlev-1
-          DCL.uestlv(levels[i],levels[i+1],patterns[i])
-        end
-        DCL.uestlv(levels[-1],DCL.glpget('rmiss'),patterns[-1])
-      when -1
-        DCL.uestlv(DCL.glpget('rmiss'),levels[0],patterns[0])
-        for i in 1...nlev
-          DCL.uestlv(levels[i-1],levels[i],patterns[i])
-        end
-        DCL.uestlv(levels[-1],DCL.glpget('rmiss'),patterns[-1])
-      else
-        raise ArgumentError,
-          "lengths of levels(#{nlev}) and patterns(#{npat}) are inconsistent"
-      end
-      nil
-    end
-
-    ############################################################
-    # RELATIVELY INDEPENDENT OF DCL SUBLIBRARIES
-    ############################################################
-
-    # <<< longitude/latitude axes package >>>
-
-    @@lon_ax_options = Misc::KeywordOptAutoHelp.new(
-      ['yax', false, 'true => y-axis, false => x-axis'],
-      ['cside', nil, '"b", "t", "l", "r", nil (=>left/bottom), or false (=>right/top)'],
-      ['dtick1', nil, 'Interval of small tickmark (if nil, internally determined)'],
-      ['dtick2', nil, 'Interval of large tickmark with labels (if nil, internally determined)']
-    )
-
-    def lon_ax(options=nil)
-      opt = @@lon_ax_options.interpret(options)
-
-      yax = opt['yax']
-      xax = !yax
-      if xax
-        xy='x'
-      else
-        xy='y'
-      end
-
-      if opt['cside']
-        cside = opt['cside']
-      elsif opt['cside'].nil?
-        if xax
-          cside='b'
-        else
-          cside='l'
-        end
-      else
-        if xax
-          cside='t'
-        else
-          cside='r'
-        end
-      end
-
-      vxmin, vxmax, vymin, vymax = DCL.sgqvpt
-      uxmin, uxmax, uymin, uymax = DCL.sgqwnd
-      if xax
-        vmin, vmax = [vxmin,vxmax].min, [vxmin,vxmax].max
-        umin, umax = [uxmin,uxmax].min, [uxmin,uxmax].max
-      else
-        vmin, vmax = [vymin,vymax].min, [vymin,vymax].max
-        umin, umax = [uymin,uymax].min, [uymin,uymax].max
-      end
-
-      # get dtick1 & dtick2
-      dtick1 = opt['dtick1']
-      dtick2 = opt['dtick2']
-      unless dtick1 && dtick2
-        irota = DCL.uzpget("irotl#{xy}#{cside}")
-        irota += 1 if yax
-        mode = irota.modulo(2)
-        DCL.ususcu(xy.capitalize,umin,umax,vmin,vmax,mode)
-        dtick1 = DCL.uspget("d#{xy}t") unless dtick1
-        dtick2 = DCL.uspget("d#{xy}l") unless dtick2
-      end
-
-      lepsl = DCL.glpget('lepsl')
-      repsl = DCL.glpget('repsl')
-      DCL.glpset('lepsl',true)
-
-      # generate numbers for small tickmarks
-      nn = 0
-      rx = DCL.irle(umin/dtick1)*dtick1
-      if DCL.lreq(umin,rx)
-        x = rx
-      else
-        x = rx + dtick1
-      end
-      u1 = []
-      while DCL.lrle(x,umax)
-        if x.abs < dtick1*repsl*nn
-          x = 0.0
-        end
-        u1[nn] = x
-        nn = nn + 1
-        x = x + dtick1
-      end
-
-      # generate numbers for large tickmarks and labels
-      nn = 0
-      rx = DCL.irle(umin/dtick2)*dtick2
-      if DCL.lreq(umin,rx)
-        x = rx
-      else
-        x = rx + dtick2
-      end
-      u2 = []
-      while DCL.lrle(x,umax)
-        if x.abs < dtick2*repsl*nn
-          x = 0
-        end
-        u2[nn] = x
-        nn = nn + 1
-        x = x + dtick2
-      end
-
-      # generate labels
-      c2 = NArray.to_na(u2)
-      c2[c2.gt(180)] -= 360.0
-      c2[c2.lt(-180)] += 360.0
-      c2[c2.eq(-180)] = 180.0
-      c2 = c2.to_a.collect do |c|
-        if c == 0 || c == 180
-          c.to_i.to_s
-        elsif c > 0
-          c.to_i.to_s + 'E'
-        else
-          c.abs.to_i.to_s + 'W'
-        end
-      end
-      nc = c2.collect{|c| c.size}.max
-
-      # call DCL.u[xy]axlb
-      if xax
-       DCL.uxaxlb(cside,u1,u2,c2,nc)
-      else
-       DCL.uyaxlb(cside,u1,u2,c2,nc)
-      end
-    end
-
-    @@lat_ax_options = Misc::KeywordOptAutoHelp.new(
-      ['xax', false, 'true => x-axis, false => y-axis'],
-      ['cside', nil, '"b", "t", "l", "r", nil (=>left/bottom), or false (=>right/top)'],
-      ['dtick1', nil, 'Interval of small tickmark (if nil, internally determined)'],
-      ['dtick2', nil, 'Interval of large tickmark with labels (if nil, internally determined)']
-    )
-
-    def lat_ax(options=nil)
-      opt = @@lat_ax_options.interpret(options)
-
-      xax = opt['xax']
-      yax = !xax
-      if xax
-        xy='x'
-      else
-        xy='y'
-      end
-
-      if opt['cside']
-        cside = opt['cside']
-      elsif opt['cside'].nil?
-        if xax
-          cside='b'
-        else
-          cside='l'
-        end
-      else
-        if xax
-          cside='t'
-        else
-          cside='r'
-        end
-      end
-
-      vxmin, vxmax, vymin, vymax = DCL.sgqvpt
-      uxmin, uxmax, uymin, uymax = DCL.sgqwnd
-      if xax
-        vmin, vmax = [vxmin,vxmax].min, [vxmin,vxmax].max
-        umin, umax = [uxmin,uxmax].min, [uxmin,uxmax].max
-      else
-        vmin, vmax = [vymin,vymax].min, [vymin,vymax].max
-        umin, umax = [uymin,uymax].min, [uymin,uymax].max
-      end
-
-      # get dtick1 & dtick2
-      dtick1 = opt['dtick1']
-      dtick2 = opt['dtick2']
-      unless dtick1 && dtick2
-        irota = DCL.uzpget("irotl#{xy}#{cside}")
-        irota += 1 if yax
-        mode = irota.modulo(2)
-        DCL.ususcu(xy.capitalize,umin,umax,vmin,vmax,mode)
-        dtick1 = DCL.uspget("d#{xy}t") unless dtick1
-        dtick2 = DCL.uspget("d#{xy}l") unless dtick2
-      end
-
-      lepsl = DCL.glpget('lepsl')
-      repsl = DCL.glpget('repsl')
-      DCL.glpset('lepsl',true)
-
-      # generate numbers for small tickmarks
-      nn = 0
-      rx = DCL.irle(umin/dtick1)*dtick1
-      if DCL.lreq(umin,rx)
-        x = rx
-      else
-        x = rx + dtick1
-      end
-      u1 = []
-      while DCL.lrle(x,umax)
-        if x.abs < dtick1*repsl*nn
-          x = 0.0
-        end
-        u1[nn] = x
-        nn = nn + 1
-        x = x + dtick1
-      end
-
-      # generate numbers for large tickmarks and labels
-      nn = 0
-      rx = DCL.irle(umin/dtick2)*dtick2
-      if DCL.lreq(umin,rx)
-        x = rx
-      else
-        x = rx + dtick2
-      end
-      u2 = []
-      while DCL.lrle(x,umax)
-        if x.abs < dtick2*repsl*nn
-          x = 0
-        end
-        u2[nn] = x
-        nn = nn + 1
-        x = x + dtick2
-      end
-
-      # generate labels
-      c2 = NArray.to_na(u2)
-      c2 = c2.to_a.collect do |c|
-        if c == 0
-          'EQ'
-        elsif c > 0
-          c.to_i.to_s + 'N'
-        else
-          c.abs.to_i.to_s + 'S'
-        end
-      end
-      nc = c2.collect{|c| c.size}.max
-
-      # call DCL.u[xy]axlb
-      if xax
-        DCL.uxaxlb(cside,u1,u2,c2,nc)
-      else
-        DCL.uyaxlb(cside,u1,u2,c2,nc)
-      end
-    end
-
-    # <<< flow vector package >>>
-
-    def __truncate(float, order=2)
-      # truncate (round) a floating number with the number digits
-      # specified by "order".
-      # e.g., if order=3, -0.012345 => -0.0123;  6.6666 => 6.67
-      exponent = 10**(-Math::log10(float.abs).floor+order-1)
-      (float * exponent).round.to_f/exponent
-    end
-
-    @@unit_vect_options = Misc::KeywordOptAutoHelp.new(
-      ['vxunit', 0.05, "x unit vect len in V coord. Used only when fxunit is omitted (default)"],
-      ['vyunit', 0.05, "y unit vect len in V coord. Used only when fyunit is omitted (default)"],
-      ['vxuloc', nil, "Starting x position of unit vect"],
-      ['vyuloc', nil, "Starting y position of unit vect"],
-      ['vxuoff', 0.05, "Specify vxuloc by offset from right-bottom corner"],
-      ['vyuoff', 0.0, "Specify vyuloc by offset from right-bottom corner"],
-      ['inplace',true, "Whether to print labels right by the unit vector (true) or below the x axis (false)"],
-      ['rsizet', nil, "Label size(default taken from uz-parameter 'rsizel1')"],
-      ['index',  3," Line index of the unit vector"]
-    )
-
-    def set_unit_vect_options(options)
-      @@unit_vect_options.set(options)
-    end
-
-    @@next_unit_vect_options = nil
-    def next_unit_vect_options(options)
-      if options.is_a?(Hash)
-        @@next_unit_vect_options = options
-      else
-        raise TypeError,"Hash expected"
-      end
-      nil
-    end
-
-    def unit_vect( vxfxratio,   # (V cood length)/(actual length) in x
-                   vyfyratio,   # (V cood length)/(actual length) in y
-                   fxunit=nil,  # If specified, x unit vect len
-                   fyunit=nil,  # If specified, y unit vect len
-                   options=nil )
-      #< options >
-      if @@next_unit_vect_options
-        options = ( options ? @@next_unit_vect_options.update(options) :
-                              @@next_unit_vect_options )
-        @@next_unit_vect_options = nil
-      end
-      opt = @@unit_vect_options.interpret(options)
-      vxunit = opt['vxunit']
-      vyunit = opt['vyunit']
-      vxuloc = opt['vxuloc']
-      vyuloc = opt['vyuloc']
-      rsizet = opt['rsizet']
-      index = opt['index']
-
-      #< unit vector >
-      if fxunit
-        vxunit = vxfxratio * fxunit
-      else
-        fxunit = vxunit / vxfxratio
-      end
-      if fyunit
-        vyunit = vyfyratio * fyunit
-      else
-        fyunit = vyunit / vyfyratio
-      end
-      fxunit = __truncate( (uxusv=fxunit) )
-      fyunit = __truncate( (uyusv=fyunit) )
-      vxunit = vxunit * (fxunit/uxusv)
-      vyunit = vyunit * (fyunit/uyusv)
-      if !(vxuloc && vyuloc)
-        vx0,vx1,vy0,vy1 = DCL.sgqvpt
-        vxuloc = vx1 + opt['vxuoff'] if !vxuloc
-        vyuloc = vy0 + opt['vyuoff'] if !vyuloc
-      end
-      DCL.sglazv( vxuloc, vyuloc,  vxuloc+vxunit, vyuloc,        1, index )
-      DCL.sglazv( vxuloc, vyuloc,  vxuloc,        vyuloc+vyunit, 1, index )
-
-      #< labelling >
-      sfxunit = sprintf("%.2g",fxunit)
-      sfyunit = sprintf("%.2g",fyunit)
-      rsizet = DCL.uzpget('rsizel1') if !rsizet
-      if opt['inplace']
-        DCL.sgtxzv(vxuloc, vyuloc-1.2*rsizet,
-                   sfxunit, rsizet, 0, -1, index)
-        DCL.sgtxzv(vxuloc+1.2*rsizet, vyuloc+0.5*rsizet,
-                   sfyunit, rsizet, 90, -1, index)
-      else
-        msg= "UNIT VECTOR X:#{sfxunit} Y:#{sfyunit}"
-        before = uz_set_params({'rsizec1'=>rsizet})
-        DCL.uxsttl('b',' ',0.0)
-        DCL.uxsttl('b',msg,0.0)
-        uz_set_params(before)
-      end
-    end
-
-    def flow_vect( fx, fy, factor=1.0, xintv=1, yintv=1,
-                   vxfxratio=nil, vyfyratio=nil)
-      raise ArgumentError,"Expect 2D arrays" if fx.rank != 2 || fy.rank != 2
-      raise ArgumentError,"fx.shape != fy.shape" if fx.shape != fy.shape
-      raise ArgumentError,"xintv must be a positive integer" if xintv < 0
-      raise ArgumentError,"yintv must be a positive integer" if yintv < 0
-      nx, ny = fx.shape
-      if xintv >= 2
-        idx = NArray.int(nx/xintv).indgen!*xintv  # [0,xintv,2*xintv,..]
-        fx = fx[idx, true]
-        fy = fy[idx, true]
-      end
-      if yintv >= 2
-        idx = NArray.int(ny/yintv).indgen!*yintv  # [0,yintv,2*yintv,..]
-        fx = fx[true, idx]
-        fy = fy[true, idx]
-      end
-      nx, ny = fx.shape  # again, because of xintv & yintv
-      vx0,vx1,vy0,vy1 = DCL.sgqvpt
-      wnd = DCL.sgqwnd
-      if wnd.include?(DCL.glrget('rundef'))
-        ux0,ux1,uy0,uy1 = DCL.sgqtxy
-      else
-        ux0,ux1,uy0,uy1 = wnd
-      end
-      dvx = (vx1-vx0)/nx
-      dvy = (vy1-vy0)/ny
-      ax = (vx1-vx0)/(ux1-ux0)   # factor to convert from U to V coordinate
-      ay = (vy1-vy0)/(uy1-uy0)   # factor to convert from U to V coordinate
-      fxmx = fx.abs.max
-      fymx = fy.abs.max
-      raise "fx has no data or all zero" if fxmx == 0
-      raise "fy has no data or all zero" if fymx == 0
-      cn = [ dvx/(ax*fxmx),  dvy/(ay*fymx) ].min  # normarization constant
-      vxfxratio = factor*cn*ax if !vxfxratio
-      vyfyratio = factor*cn*ay if !vyfyratio
-      before = ug_set_params( {'LNRMAL'=>false, 'LMSG'=>false,
-                               'XFACT1'=>1.0, 'YFACT1'=>1.0} )
-      DCL.ugvect( vxfxratio*fx, vyfyratio*fy )
-      ug_set_params( before )
-      unit_vect_info = [ vxfxratio, vyfyratio, fxmx, fymx ]
-      return unit_vect_info
-    end
-
-    def flow_itr5( gpx, gpy, factor=1.0, unit_vect=false )
-      raise ArgumentError,"Expect 2D arrays" if gpx.rank != 2 || gpy.rank != 2
-      raise ArgumentError,"gpx.shape != gpy.shape" if gpx.shape != gpy.shape
-
-      raise "Transform. No. should be 5" if DCL.sgpget('itr') != 5
-
-      theta = gpx.coord(1) / 180 * Math::PI
-      theta = theta.reshape(1,theta.shape[0])
-
-      vx = gpx * theta.cos - gpy * theta.sin   # UC component -> VC
-      vy = gpx * theta.sin + gpy * theta.cos   # UC component -> VC
-
-      DCL.sglset('LCLIP',false)
-      before1 = DCLExt.ug_set_params(
-                   {'LUNIT'=>true, 'LUMSG'=>true} ) if unit_vect
-      before2 = DCLExt.ug_set_params(
-                   {'LNRMAL'=>false,
-                    'XFACT1'=>factor, 'YFACT1'=>factor} ) if factor != 1.0
-      DCL.ugvect( vx.val, vy.val )
-
-      if unit_vect
-        uxunit = sprintf("%.2g",DCL.ugrget('UXUNIT'))
-        uyunit = sprintf("%.2g",DCL.ugrget('UXUNIT'))
-        vxuloc = DCL.ugrget('VXULOC')
-        vyuloc = DCL.ugrget('VYULOC')
-        rsize  = DCL.ugrget('RSIZET')
-        dv = rsize
-        DCL.sgtxzv(vxuloc, vyuloc-dv, uxunit, rsize,  0, -1, 3 )
-        DCL.sgtxzv(vxuloc-dv, vyuloc, uyunit, rsize, 90, -1, 3 )
-      end
-
-      ug_set_params( before2 ) if factor != 1.0
-      ug_set_params( before1 ) if unit_vect
-    end
-
-    ######################################
-
-    # <<< color bar >>>
-
-    @@color_bar_options =  Misc::KeywordOptAutoHelp.new(
-      ["levels",  nil, "tone levels (if omitted, latest ones are used)"],
-      ["patterns", nil, "tone patterns (~colors) (if omitted, latest ones are used)"],
-      ["voff", nil, "how far is the bar from the viewport in the V coordinate"],
-      ["vcent",nil, "center position of the bar in the V coordinate (VX or VY)"],
-      ["vlength", 0.3, "bar length in the V coordinate"],
-      ["vwidth", 0.02, "bar width in the V coordinate"],
-      ["inffact", 2.25, "factor to change the length of triangle on the side for infinity (relative to 'vwidth')"],
-      ["landscape", false, "if true, horizonlly long (along x axes)"],
-      ["portrait", true, "if true, vertically long (along y axes)"],
-      ["top",  false, "place the bar at the top (effective if landscape)"],
-      ["left", false, "place the bar in the left (effective if portrait)"],
-      ["units", nil, "units of the axis of the color bar"],
-      ["units_voff", 0.0, "offset value for units from the default position in the V coordinate (only for 'units' != nil)"],
-      ["title", nil, "title of the color bar"],
-      ["title_voff", 0.0, "offset value for title from the default position in the V coordinate (only for 'title' != nil)"],
-      ["tickintv", 1, "0,1,2,3,.. to specify how frequently the dividing tick lines are drawn (0: no tick lines, 1: every time, 2: ever other:,...)"],
-      ["labelintv", nil, "0,1,2,3,.. to specify how frequently labels are drawn (0: no labels, 1: every time, 2: ever other:,... default: internally determined)"],
-      ["labels_ud", nil, "user-defined labels for replacing the default labels (Array of String)"],
-      ["charfact", 0.9, "factor to change the label/units/title character size (relative to 'rsizel1')"],
-      ["log", false, "set the color bar scale to logarithmic"],
-      ["constwidth", false, "if true, each color is drawn with the same width"],
-      ["index", nil, "index of tick lines and bar frame"],
-      ["charindex", nil, "index of labels, units, and title"],
-      ["chval_fmt", nil, "string to specify the DCL.chval format for labeling"]
-    )
-
-    def set_color_bar_options(options)
-      @@color_bar_options.set(options)
-    end
-
-    def level_chval_fmt(max,min,dx)
-      # returns a format for DCL.chval suitable for color-ba labels
-      dxabs = dx.abs
-      eps = 1e-4 * dxabs
-      order = Math::log10(dxabs).floor
-      if ( (dxabs+eps*0.1) % 10**order < eps )
-        # 1 keta
-        least_order = order
-      else
-        # >=2 keta --> limit to 2 keta
-        least_order = order - 1
-      end
-      ng = Math::log10([max.abs,min.abs,eps].max).floor - least_order + 1
-      if ng <= 3
-        fmt = 'b'
-      else
-        n = Math::log10([max.abs,min.abs].max).floor
-        nn = Math::log10([max.abs,min.abs].min).floor
-        if least_order >= 0 and nn >= 0
-          ifg = 'i'
-        elsif 0 <= n and n <= 4
-          ifg = 'f'
-        else
-          ifg = 'g'
-        end
-        case(ifg)
-        when 'i'
-          fmt = '(i15)'
-        when 'g'
-          ng = Math::log10([max.abs,min.abs,eps].max).floor - least_order + 1
-          ng = [ ng, 2 ].max
-          fmt = "(g15.#{ng})"
-        when 'f'
-          nf = [ -least_order, 0].max
-          fmt = "(f15.#{nf})"
-        end
-      end
-      fmt
-    end
-
-    def sprintf_level(x,max,min,dx)
-      # format a float for color-bar labels.
-      # like DCL.hval('b',x) but changes according to dx
-      if x==0
-        fg = 'f'
-      else
-        n = Math::log10(x.abs).floor
-        if 0 <= n and n <= 4
-          fg = 'f'
-        else
-          fg = 'g'
-        end
-      end
-      eps = 1e-6
-      if ( dx.abs % 10**Math::log10(dx.abs) < eps )
-        # 1 keta
-        least_order = Math::log10(dx.abs).floor
-      else
-        # >=2 keta --> limit to 2 keta
-        least_order = Math::log10(dx.abs).floor - 1
-      end
-      if fg == 'g'
-        ng = Math::log10([max.abs,min.abs,eps].max).floor - least_order + 1
-        ng = [ ng, 2 ].max
-        fmt = "%.#{ng}g"
-      else
-        nf = [ -least_order, 0].max
-        fmt = "%.#{nf}f"
-      end
-      sprintf(fmt,x).sub(/\.0*$/,'')
-    end
-
-    def color_bar(options=nil)
-
-      # < set parameters >
-      opt = @@color_bar_options.interpret(options)
-      lsetx = DCL.uwqgxz
-      lsety = DCL.uwqgyz
-
-      rmiss = DCL.glrget('rmiss')
-
-      levels = opt['levels']
-      patterns = opt['patterns']
-
-      if (levels.nil? && !patterns.nil?) || (!levels.nil? && patterns.nil?)
-        raise "levels and patterns must be set at same time\n"
-      end
-
-      landscape = opt["landscape"] || !opt["portrait"]
-      portrait  = ! landscape
-
-      if !levels.nil?
-        ue_set_tone(levels,patterns)
-      end
-
-      labels_ud = opt["labels_ud"]
-      if !labels_ud.nil?
-        if labels_ud.class != Array
-          raise ArgumentError,"'labels_ud' must be an Array of String"
-        elsif labels_ud.size == 0
-          raise ArgumentError,"'labels_ud' must be an Array of String"
-        else
-          labels_ud.each do |lbl_ud|
-            if lbl_ud.class != String
-              raise ArgumentError,"'labels_ud' must be an Array of String"
-            end
-          end
-        end
-      end
-
-      if opt["index"]
-        index = opt["index"]
-        index = 1 if index <= 0
-      else
-        index = DCL::uziget("indext2")
-      end
-      indext1_bk = DCL::uziget("indext1")
-      indext2_bk = DCL::uziget("indext2")
-      DCL::uziset("indext1",index)
-      DCL::uziset("indext2",index)
-
-      if opt["charindex"]
-        charindex = opt["charindex"]
-        charindex = 1 if charindex <= 0
-      else
-        charindex = DCL::uziget("indexl1")
-      end
-      indexl1_bk = DCL::uziget("indexl1")
-      DCL::uziset("indexl1",charindex)
-
-      charfact = opt["charfact"]
-      rsizel1_bk = DCL::uzrget("rsizel1")
-      DCL::uzrset("rsizel1",charfact*rsizel1_bk)
-
-      nton = DCL::ueqntl
-      if nton==0
-        raise "no tone patern was set\n"
-      end
-      lev1 = Array.new
-      lev2 = Array.new
-      patterns = Array.new if !opt['patterns']
-      for n in 0..nton-1
-        tlev1,tlev2,ipat = DCL::ueqtlv(n+1)
-        lev1.push(tlev1)
-        lev2.push(tlev2)
-        patterns.push(ipat) if !opt['patterns']
-      end
-
-      #levels = lev1+lev2
-      #levels = levels.uniq.sort
-      #levels.delete(rmiss)
-      #if levels.ne(levels.sort).any?
-      #  raise "levels is not in order\n"
-      #end
-
-      levels = lev1.push(lev2[-1]) if !levels
-      levels = NArray.to_na(levels) if levels.is_a?(Array)
-      patterns = NArray.to_na(patterns) if patterns.is_a?(Array)
-
-      vx1, vx2, vy1, vy2 = DCL.sgqvpt
-
-      if opt['log']
-        lv = levels[levels.ne(rmiss).where]
-        if lv.length >= 4 && lv[0]*lv[-1]<0
-          iturn = 0
-          for i in 0...levels.length
-            if levels[i] != rmiss
-              if levels[i]*lv[0] < 0
-                iturn = i
-                break
-              end
-            end
-          end
-          opt['vlength'] /= 2
-          vc0 = opt['vcent'] || ( portrait && (vy1+vy2)/2) || (vx1+vx2)/2
-
-          opt["voff"] ||=
-                DCL.uzrget('pad1')*DCL::uzrget("rsizec2") +
-               ( portrait ? DCL.uzrget('roffyr') : - DCL.uzrget('roffxb') )
-
-          vsep2 = 0.02
-
-          opt['levels']   = levels[0..iturn-1]
-          opt['patterns'] = patterns[0..iturn-2]
-          opt['vcent'] = vc0 - opt['vlength']/2 - vsep2
-          units = opt['units']
-          opt['units'] = nil
-          color_bar(opt)
-
-          opt['levels']   = levels[iturn..-1]
-          opt['patterns'] = patterns[iturn..-1]
-          opt['vcent'] = vc0 + opt['vlength']/2 + vsep2
-          opt['units'] = units
-          color_bar(opt)
-
-          # fill between the two bars
-          if portrait
-            x1 = vx2 + opt["voff"]
-            x2 = x1 + opt['vwidth']
-            y1 = vc0 - vsep2
-            y2 = vc0 + vsep2
-          else
-            x1 = vc0 - vsep2
-            x2 = vc0 + vsep2
-            y1 = vy1 - opt["voff"]
-            y2 = y1 - opt['vwidth']
-          end
-          bk = DCLExt.sg_set_params({'lclip'=>false})
-          DCL.sgtnzv([x1,x2,x2,x1],[y1,y1,y2,y2],patterns[iturn-1])
-          DCL.sgplzv([x1,x2,x2,x1,x1],[y1,y1,y2,y2,y1],1,3)
-          DCLExt.sg_set_params(bk)
-          return
-        end
-      end
-
-      if levels.length <= 1
-        $stderr.print( "WARNING #{__FILE__}:#{__LINE__}: # of levels <= 1. No color bar is drawn." )
-        return
-      end
-
-      itrsv = DCL::sgqtrn
-      if itrsv <= 4
-        ux1sv, ux2sv, uy1sv, uy2sv = DCL.sgqwnd
-      else
-        simfacsv, vxoffsv, vyoffsv = DCL.sgqsim
-        plxsv, plysv, plrotsv = DCL.sgqmpl()
-      end
-
-      vwidth = opt["vwidth"]
-      vlength = opt["vlength"]
-
-      if portrait
-        if !opt["left"]
-          # left
-          voff =  opt["voff"] ||
-              DCL.uzrget('roffyr') + DCL.uzrget('pad1')*DCL::uzrget("rsizec2")
-          vxmin = vx2 + voff
-          vxmax = vx2 + voff + vwidth
-        else
-          # right
-          voff =  opt["voff"] ? -opt["voff"] : \
-              DCL.uzrget('roffyl') - DCL.uzrget('pad1')*DCL::uzrget("rsizec2")
-          vxmax = vx1 + voff
-          vxmin = vx1 + voff - vwidth
-        end
-        vymin =( opt["vcent"] ? opt["vcent"]-vlength/2 : vy1 )
-        vymax =( opt["vcent"] ? opt["vcent"]+vlength/2 : vy1+vlength )
-      else  ## landscape ##
-        vxmin =( opt["vcent"] ? opt["vcent"]-vlength/2 : (vx1+vx2)/2-vlength/2 )
-        vxmax =( opt["vcent"] ? opt["vcent"]+vlength/2 : (vx1+vx2)/2+vlength/2 )
-        if opt["top"]
-          # top
-          voff =  opt["voff"] ||
-               DCL.uzrget('roffxt') + DCL.uzrget('pad1')*DCL::uzrget("rsizec2")
-          vymin = vy2 + voff
-          vymax = vy2 + voff + vwidth
-        else
-          # bottom
-          voff =  opt["voff"] ? -opt["voff"] : \
-               DCL.uzrget('roffxb') - DCL.uzrget('pad1')*DCL::uzrget("rsizec2")
-          vymax = vy1 + voff
-          vymin = vy1 + voff - vwidth
-        end
-      end
-
-      min = levels[levels.ne(rmiss).where].min
-      max = levels[levels.ne(rmiss).where].max
-      if levels[0] == rmiss
-        inf0 = true
-        dummy1,dummy2,ipat0 = DCL::ueqtlv(1)
-        return if levels.length==2
-      else
-        inf0 = false
-      end
-      if levels[-1] == rmiss
-        inf1 = true
-        dummy1,dummy2,ipat1 = DCL::ueqtlv(nton)
-        return if levels.length==2
-      else
-        inf1 = false
-      end
-
-      # < paint color tones >
-
-      lclip_bk = DCL::sglget("lclip")
-      DCL::sglset("lclip", false)
-
-      inffact = opt["inffact"]
-      if opt["constwidth"]
-
-        if inf0
-          levels = levels[1..-1]
-          patterns = patterns[1..-1]
-        end
-        if inf1
-          levels = levels[0..-2]
-          patterns = patterns[0..-2]
-        end
-        nlev = levels.length
-        npat = patterns.length
-
-        if portrait
-          vy = (NArray.sfloat(npat+1).indgen!)*(vymax-vymin)/npat + vymin
-
-          # paint color tones for infinity (with drawing frame)
-          if inf0
-            vy3 = [vymin, vymin-vwidth*inffact, vymin]
-            vx3 = [vxmax, (vxmax+vxmin)/2, vxmin]
-            DCL.sgtnzv(vx3,vy3,ipat0)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-          if inf1
-            vy3 = [vymax, vymax+vwidth*inffact, vymax]
-            vx3 = [vxmax, (vxmax+vxmin)/2, vxmin]
-            DCL.sgtnzv(vx3,vy3,ipat1)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-
-          # paint color tones for each range (with drawing long-side frame)
-          for i in 0..npat-1
-            DCL::sgtnzv([vxmin,vxmax,vxmax,vxmin],[vy[i],vy[i],vy[i+1],vy[i+1]],patterns[i])
-            DCL::sgplzv([vxmin,vxmin],[vy[i],vy[i+1]],1,index)
-            DCL::sgplzv([vxmax,vxmax],[vy[i],vy[i+1]],1,index)
-          end
-
-        else ## landscape ##
-          vx = (NArray.sfloat(npat+1).indgen!)*(vxmax-vxmin)/npat + vxmin
-
-          # paint color tones for infinity (with drawing frame)
-          if inf0
-            vx3 = [vxmin, vxmin-vwidth*inffact, vxmin]
-            vy3 = [vymax, (vymax+vymin)/2, vymin]
-            DCL.sgtnzv(vx3,vy3,ipat0)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-          if inf1
-            vx3 = [vxmax, vxmax+vwidth*inffact, vxmax]
-            vy3 = [vymax, (vymax+vymin)/2, vymin]
-            DCL.sgtnzv(vx3,vy3,ipat1)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-
-          # paint color tones for each range (with drawing long-side frame)
-          for i in 0..npat-1
-            DCL::sgtnzv([vx[i],vx[i],vx[i+1],vx[i+1]],[vymin,vymax,vymax,vymin],patterns[i])
-            DCL::sgplzv([vx[i],vx[i+1]],[vymin,vymin],1,index)
-            DCL::sgplzv([vx[i],vx[i+1]],[vymax,vymax],1,index)
-          end
-        end
-
-      else  ### opt["constwidth"] == false ###
-
-        # paint color tones for infinity (with drawing frame)
-        if portrait
-          if inf0
-            vy3 = [vymin, vymin-vwidth*inffact, vymin]
-            vx3 = [vxmax, (vxmax+vxmin)/2, vxmin]
-            DCL.sgtnzv(vx3,vy3,ipat0)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-          if inf1
-            vy3 = [vymax, vymax+vwidth*inffact, vymax]
-            vx3 = [vxmax, (vxmax+vxmin)/2, vxmin]
-            DCL.sgtnzv(vx3,vy3,ipat1)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-        else ## landscape ##
-          if inf0
-            vx3 = [vxmin, vxmin-vwidth*inffact, vxmin]
-            vy3 = [vymax, (vymax+vymin)/2, vymin]
-            DCL.sgtnzv(vx3,vy3,ipat0)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-          if inf1
-            vx3 = [vxmax, vxmax+vwidth*inffact, vxmax]
-            vy3 = [vymax, (vymax+vymin)/2, vymin]
-            DCL.sgtnzv(vx3,vy3,ipat1)
-            DCL.sgplzv(vx3,vy3,1,index)
-          end
-        end
-
-        # paint color tones for each range
-        nbar = 100
-        bar = NArray.float(nbar,2)
-        for i in 0..nbar-1
-          bar[i,true] = min + (max-min).to_f/(nbar-1)*i
-        end
-
-        xb = DCL::uzlget("labelxb")
-        yl = DCL::uzlget("labelyl")
-        if portrait
-          xmin = 0.0
-          xmax = 1.0
-          ymin = min
-          ymax = max
-          DCL::uzlset("labelxb",false)
-          DCL::uzlset("labelyl",true)
-          bar = bar.transpose(-1,0)
-          DCL::uwsgxa([0,1])
-          DCL::uwsgya(bar[0,true])
-        else
-          xmin = min
-          xmax = max
-          ymin = 0.0
-          ymax = 1.0
-          DCL::uzlset("labelxb",true)
-          DCL::uzlset("labelyl",false)
-          DCL::uwsgxa(bar[true,0])
-          DCL::uwsgya([0,1])
-        end
-
-        type = 1
-        if opt["log"]
-          type +=1
-          type +=1 if !portrait
-        end
-
-        DCL::grfig
-        DCL::grsvpt(vxmin,vxmax,vymin,vymax)
-        DCL::grswnd(xmin,xmax,ymin,ymax)
-        DCL::grstrn(type)
-        DCL::grstrf
-
-        DCL::uetone(bar)
-        DCL.uwsgxz(false)
-        DCL.uwsgyz(false)
-
-      end
-
-      # < set ticking and labeling levels >
-
-      if opt["labelintv"]
-        labelintv = opt["labelintv"]
-      else
-        ntn = nton
-        ntn -= 1 if inf0
-        ntn -= 1 if inf1
-        if portrait
-          labelintv = (ntn-1) / 9  + 1
-        else
-          labelintv = (ntn-1) / 5  + 1
-        end
-      end
-      if labelintv <= 0
-        no_label = true
-        labelintv = 1
-      else
-        no_label = false
-      end
-
-      tickintv = opt["tickintv"]
-      if tickintv <= 0
-        no_tick = true
-        tickintv = labelintv
-      else
-        no_tick = false
-      end
-
-      eps = 1e-5
-      dummy = -9.9e-38
-      dz = dzp = dzc = dummy
-      idu = Array.new
-      (1...levels.length).each do |i|
-        dzc = (levels[i] - levels[i-1]).abs
-        if (dzc-dzp).abs <= eps * [dzc.abs,dzp.abs].max
-          dz = dzc  # set dz if two consecutive inrements are the same
-          idu.push( i-1 )
-        end
-        dzp = (levels[i] - levels[i-1]).abs
-      end
-      if idu.length > 0
-        idumin = idu.min - 1
-        idumax = idu.max + 1
-      else
-        idumin = 0
-        idumax = levels.length-1
-      end
-      if dz != dummy
-#        if idumin == 1 and levels[0] != rmiss
-#          # to correct non-uniform intv at the beginning
-#          levels[0] = levels[1] - dz
-#          idumin = 0
-#          min = levels[0]
-#        end
-#        if idumax == levels.length-2 and levels[-1] != rmiss
-#          # to correct non-uniform intv at the end
-#          levels[-1] = levels[-2] + dz
-#          idumax = levels.length-1
-#          max = levels[-1]
-#        end
-        # use the algorithm used in DCL.udgcla
-        offs_tick = ( (-levels[idumin]/dz).round % tickintv + idumin ) % tickintv
-        offs_label = ( (-levels[idumin]/dz).round % labelintv + idumin ) % labelintv
-      else
-        md = 0
-        if ( (idx=levels.eq(0.0).where).length > 0 )
-          md = idx[0] % labelintv
-        else
-          a = levels[0...([labelintv,levels.length].min)]
-          b = a * 10**( -NMath.log10(a.abs).floor.min )
-          (0...b.length).each{|i| md=i if (b[i].round-b[i]).abs < 1e-5 }
-        end
-        offs_tick = (md % tickintv)
-        offs_label = md
-      end
-
-      if levels.length >= 4
-        lvmx = levels[1..-2].max
-        lvmn = levels[1..-2].min
-        dlv = (lvmx-lvmn) / (levels.length-3)
-      elsif levels.length == 3 or levels.length == 2
-        lvmn = lvmx = dlv = levels[1]
-      else
-        lvmn = lvmx = dlv = levels[0]
-      end
-
-      # < draw units, title, labels, and tick lines>
-
-      if opt["constwidth"]
-
-        if !no_label && labels_ud
-          ilbl = 0
-          for i in 0..nlev-1
-            if (i % labelintv) == offs_label
-              ilbl += 1
-            end
-          end
-          if labels_ud.size != ilbl
-            raise ArgumentError, "'labels_ud' must be an Array of length==#{ilbl} in this case"
-          end
-        end
-
-        if portrait
-
-          if voff > 0
-            cent = -1
-            vxlabel = vxmax+DCL::uzrget('pad1')*DCL::uzrget('rsizel1')
-            # title
-            DCL::sgtxzr(vxmin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), (vymin+vymax)/2.0+opt['title_voff'], opt['title'], DCL::uzrget('rsizel1'), 90, 0, charindex) if opt['title']
-            # units
-            DCL::sgtxzr(vxmax+DCL::uzrget('pad1')*DCL::uzrget('rsizel1'), vymax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          else
-            cent = 1
-            vxlabel = vxmin-DCL::uzrget('pad1')*DCL::uzrget('rsizel1')
-            # title
-            DCL::sgtxzr(vxmax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), (vymin+vymax)/2.0-opt['title_voff'], opt['title'], DCL::uzrget('rsizel1'), -90, 0, charindex) if opt['title']
-            # units
-            DCL::sgtxzr(vxmin-DCL::uzrget('pad1')*DCL::uzrget('rsizel1'), vymax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], opt['units'], DCL::uzrget('rsizel1'), 0, 1, charindex) if opt['units']
-          end
-
-          ilbl_ud = 0
-          for i in 0..nlev-1
-            # labels
-            if !no_label && (i % labelintv) == offs_label
-              if labels_ud
-                char = labels_ud[ilbl_ud]
-                DCL::sgtxzr(vxlabel,vy[i],char,DCL::uzrget('rsizel1'),0,cent,charindex)
-                ilbl_ud += 1
-              else
-                begin
-                  if(opt['chval_fmt'])
-                    char = DCL::chval(opt['chval_fmt'],levels[i])
-                  else
-                    char = sprintf_level(levels[i],lvmx,lvmn,dlv)
-                  end
-                  DCL::sgtxzr(vxlabel,vy[i],char,DCL::uzrget('rsizel1'),0,cent,charindex)
-                rescue
-                  DCL::sgtxzr(vxlabel,vy[i],levels[i].to_s,DCL::uzrget('rsizel1'),0,cent,charindex)
-                end
-              end
-            end
-            # tick lines and short-side frame
-            if (!no_tick && (i % tickintv) == offs_tick) || (!inf0 && i == 0) || (!inf1 && i == nlev-1)
-              DCL::sgplzv([vxmin,vxmax],[vy[i],vy[i]],1,index)
-            end
-          end
-
-        else  ## landscape ##
-          if voff > 0
-            vylabel = vymax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1')
-            # title
-            DCL::sgtxzr((vxmin+vxmax)/2.0+opt['title_voff'], vymin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['title'], DCL::uzrget('rsizel1'), 0, 0, charindex) if opt['title']
-            # units
-            DCL::sgtxzr(vxmax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], vymax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          else
-            vylabel = vymin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1')
-            # title
-            DCL::sgtxzr((vxmin+vxmax)/2.0+opt['title_voff'], vymax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['title'], DCL::uzrget('rsizel1'), 0, 0, charindex) if opt['title']
-            # units
-            DCL::sgtxzr(vxmax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], vymin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          end
-
-          ilbl_ud = 0
-          for i in 0..nlev-1
-            # labels
-            if !no_label && (i % labelintv) == offs_label
-              if labels_ud
-                char = labels_ud[ilbl_ud]
-                DCL::sgtxzr(vx[i],vylabel,char,DCL::uzrget('rsizel1'),0,0,charindex)
-                ilbl_ud += 1
-              else
-                begin
-                  if(opt['chval_fmt'])
-                    char = DCL::chval(opt['chval_fmt'],levels[i])
-                  else
-                    char = sprintf_level(levels[i],lvmx,lvmn,dlv)
-                  end
-                  DCL::sgtxzr(vx[i],vylabel,char,DCL::uzrget('rsizel1'),0,0,charindex)
-                rescue
-                  DCL::sgtxzr(vx[i],vylabel,levels[i].to_s,DCL::uzrget('rsizel1'),0,0,charindex)
-                end
-              end
-            end
-            # tick lines and short-side frame
-            if (!no_tick && (i % tickintv) == offs_tick) || (!inf0 && i == 0) || (!inf1 && i == nlev-1)
-              DCL::sgplzv([vx[i],vx[i]],[vymin,vymax],1,index)
-            end
-          end
-        end
-
-      else  ### opt["constwidth"] == false ###
-
-        inner_bk = DCL::uziget('inner')
-        uz_set_params('inner'=>1)
-
-        tick1 = Array.new
-        tick2 = Array.new
-        for i in 0..levels.length-1
-#          if i>=idumin && i<=idumax && levels[i]!=rmiss
-          if levels[i]!=rmiss
-            tick1.push(levels[i]) if (i % tickintv) == offs_tick
-            tick2.push(levels[i]) if (i % labelintv) == offs_label
-          end
-        end
-
-        if portrait
-
-          if voff > 0
-            before = uz_set_params('labelyl'=>false,'labelyr'=>true,'icentyr'=>-1.0)
-          else
-            before = uz_set_params('labelyl'=>true,'labelyr'=>false,'icentyl'=>1.0)
-          end
-
-          # draw frame, tick lines, and labels
-          cfmt_bk = DCL::uyqfmt
-          if opt["log"]
-            fmt = opt['chval_fmt'] || "b"
-          else
-            fmt = opt['chval_fmt'] || level_chval_fmt(lvmx,lvmn,dlv)
-          end
-          DCL::uysfmt(fmt)
-
-          rsizet1_bk = DCL::uzrget("rsizet1")
-          rsizet2_bk = DCL::uzrget("rsizet2")
-          uz_set_params('rsizet1'=>vwidth,'rsizet2'=>0.0)
-          if no_label
-            nl_labelxt = DCL::uzlget('labelxt')
-            nl_labelxb = DCL::uzlget('labelxb')
-            nl_labelyl = DCL::uzlget('labelyl')
-            nl_labelyr = DCL::uzlget('labelyr')
-            uz_set_params('labelxt'=>false,'labelxb'=>false,'labelyl'=>false,'labelyr'=>false)
-          end
-          if no_tick
-            nt_rsizet1 = DCL::uzrget('rsizet1')
-            DCL::uzrset("rsizet1",0.0)
-          end
-
-          if labels_ud
-            if labels_ud.size != tick2.size
-              raise ArgumentError, "'labels_ud' must be an Array of length==#{tick2.size} in this case"
-            end
-            nc = labels_ud.collect{|c| c.size}.max
-            DCL::uyaxlb("l",tick1,tick2,labels_ud,nc)
-            DCL::uyaxlb("r",tick1,tick2,labels_ud,nc)
-          else
-            DCL::uyaxnm("l",tick1,tick2)
-            DCL::uyaxnm("r",tick1,tick2)
-          end
-          DCL::uxaxdv("b",1,index) if !inf0
-          DCL::uxaxdv("t",1,index) if !inf1
-
-          if no_tick
-            DCL::uzrset("rsizet1",nt_rsizet1)
-          end
-          if no_label
-            uz_set_params('labelxt'=>nl_labelxt,'labelxb'=>nl_labelxb,'labelyl'=>nl_labelyl,'labelyr'=>nl_labelyr)
-          end
-          DCL::uzrset("rsizet1",rsizet1_bk)
-          DCL::uzrset("rsizet2",rsizet2_bk)
-
-          DCL::uysfmt(cfmt_bk)
-
-          if voff > 0
-            # title
-            DCL::sgtxzr(vxmin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), (vymin+vymax)/2.0+opt['title_voff'], opt['title'], DCL::uzrget('rsizel1'), 90, 0, charindex) if opt["title"]
-            # units
-            DCL::sgtxzr(vxmax+DCL::uzrget('pad1')*DCL::uzrget('rsizel1'), vymax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          else
-            # title
-            DCL::sgtxzr(vxmax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), (vymin+vymax)/2.0-opt['title_voff'], opt['title'], DCL::uzrget('rsizel1'), -90, 0, charindex) if opt["title"]
-            # units
-            DCL::sgtxzr(vxmin-DCL::uzrget('pad1')*DCL::uzrget('rsizel1'), vymax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], opt['units'], DCL::uzrget('rsizel1'), 0, 1, charindex) if opt['units']
-          end
-
-          uz_set_params(before)
-
-        else  ## landscape ##
-
-          if voff > 0
-            before = uz_set_params('labelxt'=>true,'labelxb'=>false)
-          else
-            before = uz_set_params('labelxt'=>false,'labelxb'=>true)
-          end
-
-          # draw frame, tick lines, and labels
-          cfmt_bk = DCL::uxqfmt
-          if opt["log"]
-            fmt = opt['chval_fmt'] || "b"
-          else
-            fmt = opt['chval_fmt'] || level_chval_fmt(lvmx,lvmn,dlv)
-          end
-          DCL::uxsfmt(fmt)
-
-          rsizet1_bk = DCL::uzrget("rsizet1")
-          rsizet2_bk = DCL::uzrget("rsizet2")
-          uz_set_params('rsizet1'=>vwidth,'rsizet2'=>0.0)
-          if no_label
-            nl_labelxt = DCL::uzlget('labelxt')
-            nl_labelxb = DCL::uzlget('labelxb')
-            nl_labelyl = DCL::uzlget('labelyl')
-            nl_labelyr = DCL::uzlget('labelyr')
-            uz_set_params('labelxt'=>false,'labelxb'=>false,'labelyl'=>false,'labelyr'=>false)
-          end
-          if no_tick
-            nt_rsizet1 = DCL::uzrget('rsizet1')
-            DCL::uzrset("rsizet1",0.0)
-          end
-
-          if labels_ud
-            if labels_ud.size != tick2.size
-              raise ArgumentError, "'labels_ud' must be an Array of length==#{tick2.size} in this case"
-            end
-            nc = labels_ud.collect{|c| c.size}.max
-            DCL::uxaxlb("t",tick1,tick2,labels_ud,nc)
-            DCL::uxaxlb("b",tick1,tick2,labels_ud,nc)
-          else
-            DCL::uxaxnm("t",tick1,tick2)
-            DCL::uxaxnm("b",tick1,tick2)
-          end
-          DCL::uyaxdv("l",1,index) if !inf0
-          DCL::uyaxdv("r",1,index) if !inf1
-
-          if no_tick
-            DCL::uzrset("rsizet1",nt_rsizet1)
-          end
-          if no_label
-            uz_set_params('labelxt'=>nl_labelxt,'labelxb'=>nl_labelxb,'labelyl'=>nl_labelyl,'labelyr'=>nl_labelyr)
-          end
-          DCL::uzrset("rsizet1",rsizet1_bk)
-          DCL::uzrset("rsizet2",rsizet2_bk)
-
-          DCL::uxsfmt(cfmt_bk)
-
-          if voff > 0
-            # title
-            DCL::sgtxzr((vxmin+vxmax)/2.0+opt['title_voff'], vymin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['title'], DCL::uzrget('rsizel1'), 0, 0, charindex) if opt["title"]
-            # units
-            DCL::sgtxzr(vxmax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], vymax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          else
-            # title
-            DCL::sgtxzr((vxmin+vxmax)/2.0+opt['title_voff'], vymax+(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['title'], DCL::uzrget('rsizel1'), 0, 0, charindex) if opt["title"]
-            # units
-            DCL::sgtxzr(vxmax+2.6*DCL::uzrget('rsizel1')+opt['units_voff'], vymin-(0.5+DCL::uzrget('pad1'))*DCL::uzrget('rsizel1'), opt['units'], DCL::uzrget('rsizel1'), 0, -1, charindex) if opt['units']
-          end
-
-          uz_set_params(before)
-
-        end
-
-        DCL::uzlset("labelxb",xb)
-        DCL::uzlset("labelyl",yl)
-
-        DCL::grsvpt(vx1,vx2,vy1,vy2)
-        if itrsv <= 4
-          DCL::grswnd(ux1sv, ux2sv, uy1sv, uy2sv)
-          DCL::grstrn(itrsv)
-        else
-          DCL.sgssim(simfacsv,vxoffsv,vyoffsv)
-          DCL.sgsmpl(plxsv,plysv,plrotsv)
-        end
-        DCL::grstrf
-
-        uz_set_params('inner'=>inner_bk)
-      end
-
-      DCL::uziset("indext1",indext1_bk)
-      DCL::uziset("indext2",indext2_bk)
-      DCL::uziset("indexl1",indexl1_bk)
-      DCL::uzrset("rsizel1",rsizel1_bk)
-
-      DCL::sglset("lclip", lclip_bk)
-      nil
-    end
-
-    # Annotates line/mark type and index (and size if mark).
-    # By default it is shown in the right margin of the viewport.
-    #
-    # * str is a String to show
-    # * line: true->line ; false->mark
-    # * vx: vx of the left-hand point of legend line (or mark position).
-    #     * nil : internally determined
-    #     * Float && > 0 : set explicitly
-    #     * Float && < 0 : move it relatively to the left from the default
-    # * dx: length of the legend line (not used if mark).
-    #     * nil : internally determined
-    #     * Float && > 0 : set explicitly
-    # * vy: vy of the legend (not used if !first -- see below).
-    #     * nil : internally determined
-    #     * Float && > 0 : set explicitly
-    #     * Float && < 0 : move it relatively lower from the default
-    # * first : if false, vy is moved lower relatively from the previous vy.
-    # * mark_size : size of the mark. if nil, size is used.
-    def legend(str, type, index, line=false, size=nil,
-               vx=nil, dx=nil, vy=nil, first=true, mark_size=nil)
-
-      size = DCL::uzrget("rsizel1")*0.95 if !size
-      mark_size = size if !mark_size
-
-      vpx1,vpx2,vpy1,vpy2 = DCL.sgqvpt
-      if first
-        if !vy
-          vy = vpy2 - 0.04
-        elsif vy < 0
-          vy = ( vpy2 - 0.04 ) + vy
-        end
-        @vy = vy
-      else
-        vy = @vy - 1.5*size
-      end
-
-      if !vx
-        vx = vpx2 + 0.015
-      elsif vx < 0
-        vx = (vpx2 + 0.015) + vx
-      end
-
-      if line
-        dx=0.06 if !dx
-        vx2 = vx + dx
-        DCL::sgplzv([vx,vx2],[vy,vy],type,index)
-        DCL.sgtxzv(vx2+0.01,vy,str,size,0,-1,3)
-      else  # --> mark
-        DCL::sgpmzv([vx],[vy],type,index,mark_size)
-        DCL.sgtxzv(vx+0.015+mark_size*0.5,vy,str,size,0,-1,3)
-      end
-      nil
-    end
-
-    # Driver of quasi_log_levels with data values
-    def quasi_log_levels_z(vals, nlev=nil, max=nil, min=nil, cycle=1)
-      if max && min
-        quasi_log_levels(max.to_f, min.to_f, cycle)
-      else
-        if nlev
-          eps = 0.1
-          norder = (nlev-1.0+eps)/cycle
-        else
-          norder = 3
-        end
-        mx1 = vals.max
-        mx2 = vals.min
-        if min && min < 0
-          max = min
-          min = nil
-        elsif max && max < 0
-          min = max
-          max = nil
-        end
-        maxsv = max
-        minsv = min
-        if !max
-          max = [ mx1.abs, mx2.abs ].max.to_f
-          max = -max if mx1<0
-        end
-        if !min
-          min = max/10**norder
-        else
-          max = min*10**norder if nlev
-        end
-        if !(minsv && minsv>0) && !(maxsv && maxsv <0) && ( mx2<0 && mx1>0 )
-          min = -min
-        end
-        quasi_log_levels(max, min, cycle)
-      end
-    end
-
-    # Returns approximately log-scaled contour/tone levels as well as
-    # major/minor flags for contours. No DCL call is made in here.
-    #
-    # * cycle (Integer; 1, or 2 or 3) : number of level in one-order.
-    #   e.g. 1,10,100,.. for cycle==1; 1,3,10,30,.. for cycle==2;
-    #   1,2,5,10,20,50,.. for cycle==3
-    # * lev0, lev1 (Float) : levels are set between this two params
-    #   * if lev0 & lev1 > 0 : positive only
-    #   * if lev0 & lev1 < 0 : negative only
-    #   * if lev0 * lev1 < 0 : both positive and negative
-    #     (usig +-[lev0.abs,lev1.abs])
-    # RETURN VALUE:
-    # * [ levels, mjmn ]
-    def quasi_log_levels(lev0, lev1, cycle=1)
-      raise(ArgumentError, "lev0 is zero (non-zero required)") if lev0 == 0.0
-      raise(ArgumentError, "lev1 is zero (non-zero required)") if lev1 == 0.0
-      case cycle
-      when 1
-        cycl_levs = [1.0]
-      when 2
-        cycl_levs = [1.0, 3.0]
-      when 3
-        cycl_levs = [1.0, 2.0, 5.0]
-      else
-        raise(ArgumentError, "cycle must be 1,2,or 3, which is now #{cycle}")
-      end
-
-      if lev0 > 0 and lev1 > 0
-        positive = true
-        negative = false
-      elsif  lev0 < 0 and lev1 < 0
-        positive = false
-        negative = true
-      else
-        positive = true
-        negative = true
-      end
-      sml, big = [lev0.abs,lev1.abs].sort
-
-      expsml = Math::log10(sml).floor
-      expbig = Math::log10(big).ceil
-
-      levels = Array.new
-      mjmn = Array.new
-
-      for i in expsml..expbig-1
-        for k in 0..cycle-1
-          lev = cycl_levs[k] * 10**i
-          if lev >= sml && lev <= big
-            levels.push( lev )
-            mjmn.push( k==0 ? 1 : 0 )
-          end
-        end
-      end
-      lev = 10**expbig
-      if lev == big
-        levels.push( lev )
-        mjmn.push( 1 )
-      end
-
-      if negative && !positive
-        levels = levels.reverse.collect{|x| -x}
-        mjmn = mjmn.reverse
-      elsif negative && positive
-        levels.dup.each{|x| levels.unshift(-x)}
-        mjmn.dup.each{|x| mjmn.unshift(x)}
-      end
-
-      [ levels, mjmn ]
-    end
-  end
+=end
+############################################################
 
-  ####################################################################
-  ####################################################################
-  ####################################################################
+module NumRu
 
   module GGraph
 
@@ -3505,7 +1287,7 @@ module NumRu
             atts = opts['xreverse'].split(',').collect{|v| v.split(':')}
             xreverse = false
             atts.each{|key,val|
-              xreverse = ( xax.get_att(key) == val )
+              xreverse = ( key.downcase=="units" ? (Units.new(xax.get_att(key)) =~ Units.new(val)) : (xax.get_att(key) == val) )
               break if xreverse
             }
           end
@@ -3513,7 +1295,7 @@ module NumRu
             atts = opts['yreverse'].split(',').collect{|v| v.split(':')}
             yreverse = false
             atts.each{|key,val|
-              yreverse = ( yax.get_att(key) == val )
+              yreverse = ( key.downcase=="units" ? (Units.new(yax.get_att(key)) =~ Units.new(val)) : (yax.get_att(key) == val) )
               break if yreverse
             }
           end
@@ -3537,6 +1319,10 @@ module NumRu
               # if the max and min of the range is the same, shift them a bit
               range[0] = DCL.rgnlt(r0)
               range[1] = DCL.rgngt(r0)
+              if range[0] == range[1] # if min and max are still the same
+                range[0] -= 1
+                range[1] += 1
+              end
             end
           end
           default_window=[xrange[0], xrange[1], yrange[0], yrange[1]]
@@ -3638,7 +1424,8 @@ module NumRu
             end
           end
 
-      when 10..15
+      when 10..19
+        sv = DCL.umpget('lglobe')
         if !map_fit
           map_axis = opts['map_axis'] || [180.0, 0.0, 0.0]
           DCL::umscnt( *map_axis )
@@ -3657,6 +1444,8 @@ module NumRu
             tyrange = [ -75, 75 ]      # latange is ignored
           end
           DCL::grstxy(map_window[0], map_window[1], tyrange[0], tyrange[1])
+          # 'lglobe' becomes true when itr >= 12 or data coverage is almost global for Mercator
+          DCL.umpset('lglobe', (itr >= 12) || ((itr == 11) && (tyrange[0].abs >= 75) && (tyrange[1].abs >= 75) && (tyrange[0] * tyrange[1] < 0)))
         else
           lon_cent =( window[0] + window[1] ) / 2.0
           dlon2 = ( window[1] - window[0] ) / 2.0
@@ -3664,11 +1453,11 @@ module NumRu
           DCL::sgswnd(*window)
           DCL::umscnt( *map_axis )
           DCL::grstxy( -dlon2, dlon2, window[2], window[3] )
+          # 'lglobe' becomes true when data coverage is almost global for Mercator
+          DCL.umpset('lglobe', (itr == 11) && (window[2].abs >= 75) && (window[3].abs >= 75) && (window[2] * window[3] < 0))
         end
-        sv = DCL.umpget('lglobe')
-        DCL.umpset('lglobe', true)
         DCL::umpfit
-      when 20..33
+      when 20..34
         map_axis = opts['map_axis'] || [180.0, 90.0, 0.0]
         map_radius = opts['map_radius'] || 70.0
         DCL::umscnt( *map_axis )
@@ -3730,6 +1519,10 @@ module NumRu
                'Interval of x axis label (if nil, internally determined)'],
       ['ylabelint',  nil,
                'Interval of y axis label (if nil, internally determined)'],
+      ['xloglabelall',  false,
+               'Show lavels for all log-level tick marks (x-axes) (e.g.,1000,900,800,... inseatd of 1000,500,200,...)'],
+      ['yloglabelall',  false,
+               'Show lavels for all log-level tick marks (y-axes) (e.g.,1000,900,800,... inseatd of 1000,500,200,...)'],
       ['xmaplabel',  nil,
                'If "lon"("lat"), use DCLExt::lon_ax(DCLExt::lat_ax) to draw xaxes; otherwise, DCL::usxaxs is used.'],
       ['ymaplabel',  nil,
@@ -3851,6 +1644,10 @@ module NumRu
             DCL.uscset('cxunit', sunits)
             DCL.uspset('dxt', opts['xtickint'])  if(opts['xtickint'])
             DCL.uspset('dxl', opts['xlabelint']) if(opts['xlabelint'])
+            if(opts['xloglabelall'])
+              DCL.uspset('nlblx', 4)
+              DCL.ulsxbl([1,2,3,4,5,6,7,8,9])
+            end
             opts['xside'].split('').each{|s|     # scan('.') also works
               DCL.usxaxs(s)
             }
@@ -3886,6 +1683,10 @@ module NumRu
             DCL.uscset('cyunit', sunits )
             DCL.uspset('dyt', opts['ytickint'])  if(opts['ytickint'])
             DCL.uspset('dyl', opts['ylabelint']) if(opts['ylabelint'])
+            if(opts['yloglabelall'])
+              DCL.uspset('nlbly', 4)
+              DCL.ulsybl([1,2,3,4,5,6,7,8,9])
+            end
             opts['yside'].split('').each{|s|   # scan('.') also works
               DCL.usyaxs(s)
               if s=='l' && sunits && sunits != ''
@@ -4594,12 +2395,24 @@ module NumRu
       @@data_prep_options
     )
 
+    def name_selector(gp, limit)
+      if gp.long_name && gp.name
+        if gp.long_name.length > limit && gp.long_name.length > gp.name.length && !gp.name.empty?
+          gp.name 
+        else 
+          gp.long_name
+        end
+      else
+        gp.long_name || gp.name
+      end
+    end
+    private :name_selector
+
     def axes_or_map_and_ttl(gp, opts, xax, yax, gp2=nil)
       if !gp2
-        ttl = (opts['title'] || gp.long_name || gp.name)
+        ttl = opts['title'] || name_selector(gp, 30)
       else
-        ttl = ( opts['title'] || 
-            '('+(gp.long_name || gp.name)+','+(gp2.long_name || gp2.name)+')' )
+        ttl = opts['title'] || '(' << name_selector(gp, 15) << ',' << name_selector(gp2, 15) << ')'
       end
       if map_trn?
         map
@@ -4630,7 +2443,7 @@ module NumRu
           if map_fit
             fig(xax,yax, {'itr'=>1, 'new_frame'=>false, 'viewport'=>vpt})
             axes(xax, yax, 'title'=>ttl)
-            DCL.sgstrn(trn)
+            fig(xax,yax,{'itr'=>trn, 'new_frame'=>false, 'viewport'=>vpt, 'map_fit'=>true})
           else
             xax_map = xax[0..1].copy
             xax_map[0] = cnt[0] + wnd[0]
@@ -5132,21 +2945,26 @@ module NumRu
       DCLExt.next_unit_vect_options(options)
     end
 
-    @@vxfxratio=nil
-    @@vyfyratio=nil
+    @@vxfxratio=nil    # for flow_vect
+    @@vyfyratio=nil    # for flow_vect
+    @@vfratio=nil      # for flow_vect_anyproj
 
     @@vector_options = Misc::KeywordOptAutoHelp.new(
       ['title', nil, 'Title of the figure(if nil, internally determined)'],
       ['annotate', true, 'if false, do not put texts on the right margin even when newframe==true'],
       ['map_axes', false, '[USE IT ONLY WHEN itr=10 (cylindrical)] If true, draws axes by temprarilly switching to itr=1 and calling GGraph::axes.'],
       ['flow_vect', true, 'If true, use DCLExt::flow_vect to draw vectors; otherwise, DCL::ugvect is used.'],
+      ['flow_vect_anyproj', nil, 'Whether to use flow_vect_anyproj. If nil, up to the current projection number (when >=2); if true, always; if false, never. (precedence if higher than the flow_vect parameter)'],
       ['keep', false, 'Use the same vector scaling as in the previous call. -- Currently, works only when "flow_vect" is true'],
       ['factor', 1.0, '(Effective only if flow_vect) scaling factor to strech/reduce the arrow lengths'],
       ['unit_vect', false, 'Show the unit vector'],
       ['max_unit_vect', false, '(Effective only if flow_vect && unit_vect) If true, use the maximum arrows to scale the unit vector; otherwise, normalize in V coordinate.'],
       ['ux_unit', nil, '(If Numeric) length of the x direction unit vector (precedence of this option is lower than max_unit_vect)'],
       ['uy_unit', nil, '(If Numeric) length of the y direction unit vector (precedence of this option is lower than max_unit_vect)'],
-       ['flow_itr5', false, 'If true, use DclExt::flow_itr5 to draw vectors on 2-dim polar coordinate. Should be set DCL.sgstrn(5)'],
+      ['len_unit', nil, '(Effective only when flow_vect_anyproj is used) If Numeric, length of the the unit vector in terms of (fx,fy); if nil (defualt), the unitvecto length is set to be the maximum one'],
+      ['flow_itr5', false, 'If true, use DclExt::flow_itr5 to draw vectors on 2-dim polar coordinate. Should be set DCL.sgstrn(5)'],
+      ['polar_thinning', nil, '(Effective only when flow_vect_anyproj is used) If Numeric, specifies the maximum grid isotrpy, with which thinning is made near the poles (recommended value: 0.3 ~ 1)'],
+      ['distvect_map', true, '(effective only for flow_vect_anyproj when map projection) by default (true) it is assumed that the vector (fx,fy) is based on lengths (such as wind velocities in m/s and fluxes in which wind velocities are incorporated [q*u, q*v]); set it to false if the vector is based on angles (such as the time derivatives of longitude and latitude).'],
        @@data_prep_options
     )
 
@@ -5163,14 +2981,28 @@ module NumRu
       if newframe
         axes_or_map_and_ttl(fx, opts, xax, yax, fy)
       end
-      DCL.uwsgxa(xax.val)
-      DCL.uwsgya(yax.val)
+      itr = current_itr
+      xaxv = xax.val
+      yaxv = yax.val
+      DCL.uwsgxa(xaxv)
+      DCL.uwsgya(yaxv)
       if opts['flow_itr5']
         if itr_is?(5)
           DCLExt.flow_itr5( fx, fy, opts['factor'], opts['unit_vect'] )
         else
           raise "flow_itr5 option should use with itr=5."
         end
+      elsif opts['flow_vect_anyproj'] ||
+            ( opts['flow_vect_anyproj'].nil? && opts['flow_vect'] && itr >=2 )
+        @@vfratio, flenmax = 
+            DCLExt.flow_vect_anyproj(fx.val, fy.val, xaxv, yaxv, 
+                                     opts['factor'], 1, 1, opts['distvect_map'],
+                                     (opts['keep'] && @@vfratio),
+                                     opts['polar_thinning'] )
+        if opts['unit_vect']
+          len_unit = opts['len_unit'] || flenmax
+          DCLExt.unit_vect_single(@@vfratio, len_unit)
+        end
       elsif opts['flow_vect']
         uninfo = DCLExt.flow_vect(fx.val, fy.val, opts['factor'], 1, 1,
                   (opts['keep']&& @@vxfxratio), (opts['keep'] && @@vyfyratio) )
@@ -5334,6 +3166,7 @@ end
 if $0 == __FILE__
   include NumRu
 
+
   # < read command line option if any >
 
   if ARGV.length == 1
@@ -5348,7 +3181,8 @@ if $0 == __FILE__
   DCL.slmgn(0.0, 0.0, 0.011, 0.0)
   DCL.slsttl("#PAGE","b",1.0,1.0,0.01,1)
   DCL.sldiv('y',2,2)
-  DCL.sgpset('lcntl', false)
+  #DCL.sgpset('lcntl', false)
+  DCL.sgpset('isub', 96)      # control character of subscription: '_' --> '`'
   DCL.sgpset('lfull',true)
   DCL.sgpset('lfprop',true)
   DCL.uzfact(0.9)
@@ -5620,13 +3454,14 @@ if $0 == __FILE__
   GGraph.vector(gp_velrad, gp_vellat, true,
                 'flow_itr5'=>true,'factor'=>1e-1)
 
+  #/ graph 34/
   GGraph.next_fig('itr'=>5)
   GGraph.tone(gp_velrad,true)
   GGraph.vector(gp_velrad, gp_vellat, false,
                 'flow_itr5'=>true,'factor'=>1e-1)
+  GGraph.color_bar
 
-
-  #/ graph 34/
+  #/ graph 35/
   # vector field on the polar coordinate (2)
   #  -- demo for flow_itr5 option of GGraph.vector
 
@@ -5650,6 +3485,7 @@ if $0 == __FILE__
 
   #### draw vector field in the equatorial plane #####
 
+  #/ graph 36/
   GGraph.next_fig('itr'=>5)
   GGraph.vector(gp_velrad, gp_vellon, true,
                 'flow_itr5'=>true,'factor'=>1e-1)
@@ -5658,6 +3494,8 @@ if $0 == __FILE__
   GGraph.tone(gp_velrad,true)
   GGraph.vector(gp_velrad, gp_vellon, false,
                 'flow_itr5'=>true,'factor'=>1e-1)
+  GGraph.color_bar
+
 
 #=end
 
@@ -5750,6 +3588,7 @@ if $0 == __FILE__
   file = '../../testdata/UV.jan.nc'
   u = GPhys::NetCDF_IO.open(file, 'U')
   v = GPhys::NetCDF_IO.open(file, 'V')
+
   GGraph.scatter(u.cut("level"=>200),v.cut("level"=>200),true,
                  "title"=>"sample scatter plot of multi-D data")
 
@@ -5832,6 +3671,67 @@ if $0 == __FILE__
   GGraph.vector(gphys+10,gphys-10,true,
         {'unit_vect'=>true, 'ux_unit'=>70, 'xintv'=>2, 'yintv'=>2})
 
+  #/ graph 56 /
+
+  DCL.sgpset('lfull',true)
+  GGraph.set_fig('itr'=>1,'viewport'=>[0.08,0.82,0.23,0.57])
+  GGraph.vector(u.cut("level"=>200),v.cut("level"=>200),true,
+                'unit_vect'=>true)
+
+  #/ graph 57 /
+
+  DCL.sgpset('lfull',true)
+  GGraph.set_fig('itr'=>2,'viewport'=>[0.2,0.8,0.2,0.6])
+  GGraph.vector(u[0,false],v[0,false]*10,true,
+                'unit_vect'=>true)
+
+  #/ graph 58 /
+
+  GGraph.set_fig('itr'=>10)
+  GGraph.set_map('coast_world'=>true)
+  GGraph.vector(u.cut("level"=>200),v.cut("level"=>200),true,
+                'unit_vect'=>true,'flow_vect_anyproj'=>true,"factor"=>1.5)
+
+  #/ graph 59 /
+  GGraph.set_fig('itr'=>30,'viewport'=>[0.2,0.7,0.1,0.6])
+  GGraph.vector(u.cut("lat"=>20..90,"level"=>200),
+                v.cut("lat"=>20..90,"level"=>200),true,
+                'unit_vect'=>true)
+
+  #/ graph 60 /
+  GGraph.set_fig('itr'=>12,'viewport'=>[0.1,0.8,0.15,0.55])
+  DCLExt.next_unit_vect_options('rsizet'=>0.03,'vertical'=>false,"vxuloc"=>0.45)
+  GGraph.vector(u.cut("level"=>200),
+                v.cut("level"=>200),true,
+                'unit_vect'=>true,"len_unit"=>70)
+
+  #/ graph 61/
+  GGraph.next_fig('itr'=>14)
+  GGraph.next_map('fill'=>true)
+  GGraph.tone(gphys, true)
+  GGraph.color_bar
+  GGraph.contour(gphys, false) # contour after color_bar
+
+  #/ graph 67/
+  GGraph.next_fig('itr'=>23)
+  GGraph.next_map('fill'=>true)
+  GGraph.tone_and_contour(gphys, true, 'color_bar'=>true)
+
+  #/ graph 69/
+  GGraph.next_fig('itr'=>31,'viewport'=>[0.22,0.78,0.06,0.6])
+  GGraph.next_map('fill'=>true)
+  DCL.sgpset('lclip',true)
+  GGraph.tone(gphys, true)
+  GGraph.color_bar
+  GGraph.contour(gphys, false) # contour after color_bar
+  DCL.sgpset('lclip',false)
+
+  #/ graph 71/
+  GGraph.next_fig('itr'=>10)
+  GGraph.next_map('fill'=>true)
+  GGraph.next_axes('xtitle'=>'')
+  GGraph.tone_and_contour(gphys, true, 'map_axes'=>true, 'color_bar'=>true)
+
   ############
   DCL.grcls