module NumRu::GGraph and others in ggraph.rb

Index

module NumRu::GGraph
- margin_info Sets the strings to appear in the bottom margin.
- title Shows title by DCL.uxmttl('t',string,0.0). Graphic methods such as contour calls this by default.
- annotate Show texts on the right margin of the viewport. Graphic methods such as contour calls this by default.
- fig Define a figure by setting viewport, window, and coordinate transform id (itr) from two 1D VArrays xax and yax.
- set_fig Change the default option values for fig.
- next_fig Set the option values effective only in the next call of fig (cleared then).
- axes Draw axes using (by default) info in xax and yax if non-nil.
- set_axes Change the default option values for axes.
- next_axes Set the option values effective only in the next call of axes (cleared then).
- map_trn? Returns whether the current coordinate transformation is a map projection.
- map (For map projection) Draws map grid and/or lim and/or coast lines etc.
- set_map Change the default option values for map.
- next_map Set the option values effective only in the next call of map
- line Plot a poly-line by selecting the first dimension (with GPhys#first1D) if gphys is more than 2D.
- mark Similar to line but plots marks instead of drawing a poly-line.
- contour Contour plot by selecting the first 2 dimensions (with GPhys#first2D) if gphys is more than 3D.
- set_contour Set options for contour in general.
- next_contour Set options for contour in general, which is applied only to the next call.
- set_contour_levels Set contour levels for contour explicitly by values with the option levels.
- clear_contour_levels Clear contour levels set by set_contour_levels.
- set_linear_contour_options Change the default option values regarding linear contour level setting in contour.
- next_linear_contour_options Similar to set_linear_contour_options but the setting is effective only for the next call of contour.
- tone Color tone or shading by selecting the first 2 dimensions (with GPhys#first2D) if gphys is more than 3D.
- color_bar Color bar
- set_tone_levels Set tone levels for tone explicitly by values.
- set_tone Set options for tone in general.
- next_tone Set options for tone in general, which is applied only to the next call.
- clear_tone_levels Clear tone levels set by set_tone_levels.
- set_linear_tone_options Change the default option values regarding linear tone level setting in tone.
- next_linear_tone_options Similar to set_linear_tone_options but the setting 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).
- set_unit_vect_options
- next_unit_vect_options
- unit_vect Show the "unit vector", which indicate the vector scaling.
- 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

module NumRu::GGraph

A graphic library for GPhys using RubyDCL.

This module uses GPhys but is not a part of it. More specifically, even though this module is included in the GPhys distribution, the class NumRu::GPhys knows nothing about it, and GGraph accesses GPhys only though public methods. So GGraph is not an insider, and you can make another graphic library if you like.

Module Functions

margin_info(program=nil, data_source=nil, char_height=nil, date=nil, xl=0.0, xr=0.0, yb=nil, yt=0.0)

Sets the strings to appear in the bottom margin.

This method sets margin widths as DCL.slmgn(xl, xr, yb, yt), and sets the 1st and 2nd margin strings as program and data.

ARGUMENTS

program (String or nil) : String to be put on the left side in the bottom margin. This is meant to represent the name of the execution program. Therefore, if it is nil, the full path of $0 is used.
data_source (String or nil) : String to be put on the right side in the bottom margin. This is meant to represent the data file name or the directory in which the data are situated. If nil, the full path of the current directory is used (but nothing is shown if it is equal to the directory of the program).
date (true, false, nil) : whether to put todays date -- true: always, nil: if program.length is short enough, false: never
char_height (Float or nil) : height of the string to appear in the V coordinate. If nil, internally defined.
xl, xr, yb, yl (Float --- nil is available for yb) : margin size in the V coordinate. The margin is set as DCL.slmgn(xl, xr, yb, yt). If yb is nil, it is determined internally as 2.0 * char_height.

title(string)

Shows title by DCL.uxmttl('t',string,0.0). Graphic methods such as contour calls this by default.

RETURN VALUE

annotate(str_ary)

Show texts on the right margin of the viewport. Graphic methods such as contour calls this by default.

ARGUMENTS

str_ary (Array of String) :

RETURN VALUE

fig(xax=nil, yax=nil, options=nil)

Define a figure by setting viewport, window, and coordinate transform id (itr) from two 1D VArrays xax and yax (which are not needed if a map projection is specified with the optional parameter 'itr').

DCL.grfrm or DCL.grfig is called depending options provided.

ARGUMENTS

xax (VArray): (Used only if not map projection) A VArray representing the x (horizontal) coordinate of the figure. The x range of the window (UXMIN & UYMAX in DCL) are determined with the max and min of xax.val. By default, the min and max values are assigned to the left and right boundaries, respectively, but it is reversed if xax has a 'positive' attribute and its value is 'down' etc (see options).
yax (VArray): (Used only if not map projection) Similar to xax but for the y (vertical) coordinate of the figure.

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:
"new_frame"   true    # whether to define a new frame by DCL.grfrm
                      # (otherwise, DCL.grfig is called)
"no_new_fig"  false   # If true, neither DCL.grfrm nor DCL.grfig
                      # is called (overrides new_frame) -- Then, you need
                      # to call one of them in advance. Convenient to set
                      # DCL parameters that are reset by grfrm or grfig.
"itr"         1       # coordinate transformation number
"viewport"    [0.2, 0.8, 0.2, 0.8]    # [vxmin, vxmax, vymin, vymax]
"eqdistvpt"   false   # modify viewport to equidistant for x and y
                      # (only for itr=1--4)
"window"      nil     # (for itr<10,>50) [uxmin, uxmax, uymin, uymax],
                      # each element allowed nil (only for itr<5,>50)
"xreverse"    "positive:down,units:hPa"       # (for itr<10,>50) Assign
                      # max value to UXMIN and min value to UXMAX if
                      # condition is satisfied (nil:never, true:always,
                      # String: when an attibute has the value specified
                      # ("key:value,key:value,..")
"yreverse"    "positive:down,units:hPa"       # (for itr<10,>50) Assign
                      # max value to UYMIN and min value to UYMAX if
                      # condition is satisfied (nil:never, true:always,
                      # String: when an attibute has the value specified
                      # ("key:value,key:value,..")
"round0"      false   # expand window range to good numbers (effective
                      # only to internal window settings)
"round1"      false   # expand window range to good numbers (effective
                      # even when "window" is explicitly specified)
"similar"     nil     # (for rectangular curvilinear coordinate only)
                      # 3-element float array for similar transformation
                      # in a rectangular curvilinear coordinate, which
                      # is fed in DCL:grssim:[simfac,vxoff,vyoff],where
                      # simfac and [vxoff,vyoff] represent scaling
                      # factor and origin shift, respectively.
"map_axis"    nil     # (for all map projections) 3-element float
                      # array to be fed in DCL::umscnt: [uxc, uxy, rot],
                      # where [uxc, uyc] represents the tangential point
                      # (or the pole at top side for cylindrical
                      # projections), and rot represents the rotation
                      # angle. If nil, internally determined. (units:
                      # degrees)
"map_radius"  nil     # (for itr>=20: conical/azimuhal map
                      # projections) raidus around the tangential point.
                      # (units: degrees)
"map_fit"     nil     # (Only for itr=10(cylindrical) and 11 (Mercator))
                      # true: fit the plot to the data window
                      # (overrides map_window and map_axis); false: do
                      # not fit (then map_window and map_axis are used);
                      # nil: true if itr==10, false if itr==11
"map_window"  [-180, 180, -75, 75]    # (for itr<20: cylindrical
                      # map projections) lon-lat window [lon_min,
                      # lon_max, lat_min, lat_max ] to draw the map
                      # (units: degres)
"help"        false   # show help message if true

RETURN VALUE

POSSIBLE EXCEPTIONS

those from NumRu::DCL if any / TypeError if any
options has a key that does not match any of the option names.
options has a key that is ambiguous

set_fig(options)

Change the default option values for fig.

ARGUMENTS

options (Hash) : The usage is the same as options for fig.

RETURN VALUE

a Hash containing the values replaced (the ones before calling this method)

POSSIBLE EXCEPTIONS

see fig.

next_fig(options)

Set the option values effective only in the next call of fig (cleared then).

These value are overwritten if specified explicitly in the next call of fig.

ARGUMENTS

options (Hash) : The usage is the same as options for fig.

RETURN VALUE

POSSIBLE EXCEPTIONS

see fig.

axes(xax=nil, yax=nil, options=nil)

Draw axes using (by default) info in xax and yax if non-nil.

ARGUMENTS

xax (nil or VArray): if non-nil, attributes 'long_name' and 'units' are read to define xtitle and xunits (see below). These are overwritten by explicitly specifying xtitle and xunits.
yax (nil or VArray): if non-nil, attributes 'long_name' and 'units' are read to define ytitle and yunits (see below). These are overwritten by explicitly specifying ytitle and yunits.

option name   default value   # description:
"xside"       "tb"    # Where to draw xaxes (combination of t, b and u)
"yside"       "lr"    # Where to draw yaxes (combination of l, r and u)
"xtitle"      nil     # Title of x axis (if nil, internally determined)
"ytitle"      nil     # Title of y axis (if nil, internally determined)
"xunits"      nil     # Units of x axis (if nil, internally determined)
"yunits"      nil     # Units of y axis (if nil, internally determined)
"xtickint"    nil     # Interval of x axis tickmark
                      #                 (if nil, internally determined)
"ytickint"    nil     # Interval of y axis tickmark
                      #                 (if nil, internally determined)
"xlabelint"   nil     # Interval of x axis label
                      #                 (if nil, internally determined)
"ylabelint"   nil     # Interval of y axis label
                      #                 (if nil, internally determined)
"xmaplabel"   false   # If "lon"("lat"), use
                      # DCLExt::lon_ax(DCLExt::lat_ax) to draw xaxes;
                      # otherwise, DCL::usxaxs is used.
"ymaplabel"   false   # If "lon"("lat"), use
                      # DCLExt::lon_ax(DCLExt::lat_ax) to draw yaxes;
                      # otherwise, DCL::usyaxs is used.
"time_ax"     nil     # Type of calendar-type time axis: nil (=> auto
                      # slection), false (do not use the time axis even
                      # if the units of the axis is a time one with since
                      # field), "h" (=> like nil, but always use the
                      # hour-resolving datetime_ax method in
                      # dclext_datetime_ax.rb), or "ymd" (=> like "h" but
                      # for y-m-d type using DCL.uc[xy]acl)
"help"        false   # show help message if true

RETURN VALUE

POSSIBLE EXCEPTIONS

those from NumRu::DCL if any / TypeError if any
options has a key that does not match any of the option names.
options has a key that is ambiguous

set_axes(options)

Change the default option values for axes.

ARGUMENTS

options (Hash) : The usage is the same as options for axes.

RETURN VALUE

a Hash containing the values replaced (the ones before calling this method)

POSSIBLE EXCEPTIONS

see axes.

next_axes(options)

Set the option values effective only in the next call of axes (cleared then).

These value are overwritten if specified explicitly in the next call of axes.

ARGUMENTS

options (Hash) : The usage is the same as options for axes.

RETURN VALUE

POSSIBLE EXCEPTIONS

see axes.

sim_trn?

Returns whether the current coordinate transformation is a rectangular curvelinear coordinate. A coordinate transformation must have been established with fig or DCL::grstrf. Mainly for internal usage, but a user can use it too.

RETURN VALUE

true or false

polar_coordinate_boundaries(xax=nil,yax=nil)

Draw boundaries in a polar coordinate.

ARGUMENTS

xax (VArray): Grid points of the radial coordinate.
yax (VArray): Grid points of the azimuthal coordinate.

RETURN VALUE

map_trn?

Returns whether the current coordinate transformation is a map projection.

A coordinate transformation must have been established with fig or DCL::grstrf. Mainly for internal usage, but a user can use it too.

RETURN VALUE

true or false

map(options=nil)

(For map projection) Draws map grid and/or lim and/or coast lines etc.

ARGUMENTS

option name   default value   # description:
"lim"         true    # draw map lim (t or f)
"grid"        true    # draw map grid (t or f)
"vpt_boundary" false  # draw viewport boundaries (f, t or
                      # 1,2,3.., representing the line width)
"wwd_boundary" false  # draw worksation window boundaries (f, t
                      # or 1,2,3.., representing the line width)
"fill"        false   # fill the map if coast_world or coast_japan is
                      # true (t or f)
"coast_world" false   # draw world coast lines (t or f)
"border_world" false  # draw nation borders (t or f)
"plate_world" false   # draw plate boundaries (t or f)
"state_usa"   false   # draw state boundaries of US (t or f)
"coast_japan" false   # draw japanese coast lines (t or f)
"pref_japan"  false   # draw japanese prefecture boundaries (t or
                      # f)
"dgridmj"     nil     # the interval between the major lines of
                      # latitudes and longitudes. If nil, internally
                      # determined. (units: degrees) (this is a UMPACK
                      # parameter, which is nullified when uminit or
                      # grfrm is called)
"dgridmn"     nil     # the interval between the minor lines of
                      # latitudes and longitudes. If nil, internally
                      # determined. (units: degrees) (this is a UMPACK
                      # parameter, which is nullified when uminit or
                      # grfrm is called)
"help"        false   # show help message if true

RETURN VALUE

POSSIBLE EXCEPTIONS

if called when the coordinate tansformation has not been established or the transformation is not a map projection.
those from NumRu::DCL if any / TypeError if any
options has a key that does not match any of the option names.
options has a key that is ambiguous

set_map(options)

Change the default option values for map.

ARGUMENTS

options (Hash) : The usage is the same as options for map.

RETURN VALUE

a Hash containing the values replaced (the ones before calling this method)

POSSIBLE EXCEPTIONS

see map.

next_map(options)

Set the option values effective only in the next call of map (cleared then).

These value are overwritten if specified explicitly in the next call of map.

ARGUMENTS

options (Hash) : The usage is the same as options for map.

RETURN VALUE

POSSIBLE EXCEPTIONS

see map.

line(gphys, newframe=true, options=nil)

Plot a poly-line by selecting the first dimension (with GPhys#first1D) if gphys is more than 2D.

ARGUMENTS

gphys (GPhys) : a GPhys whose data is plotted.
newframe (true/false) : if true, calls fig, axes, title, and annotate internally; if false, only the poly-line is drawn (overlaid to the exiting figure).

option name   default value   # description:
"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
"exchange"    false   # whether to exchange x and y axes
"index"       1       # line/mark index
"type"        1       # line type
"label"       nil     # if a String is given, it is shown as the label
"max"         nil     # maximum data value
"min"         nil     # minimum data value
"legend"      nil     # legend to annotate the line type and index. nil
                      # (defalut -- do not show); a String as the legend;
                      # true to use the name of the GPhys as the legend
"legend_vx"   nil     # (effective if legend) viewport x values of
                      # the lhs of the legend line (positive float); or
                      # nil for automatic settting (shown to the right of
                      # vpt); or move it to the left relatively (negtive
                      # float)
"legend_dx"   nil     # (effective if legend) length of the legend
                      # line
"legend_vy"   nil     # (effective if legend) viewport y value of the
                      # legend (Float; or nil for automatic settting)
"legend_size" nil     # (effective if legend) character size of the
                      # legend
"map_axes"    false   # [USE IT ONLY WHEN itr=10 (cylindrical)] If
                      # true, draws axes by temprarilly switching to
                      # itr=1 and calling GGraph::axes.
"help"        false   # show help message if true

RETURN VALUE

mark(gphys, newframe=true, options=nil)

Similar to line but plots marks instead of drawing a poly-line.

ARGUMENTS

gphys (GPhys) : a GPhys whose data is plotted.
newframe (true/false) : if true, calls fig, axes, title, and annotate internally; if false, only the poly-line is drawn (overlaid to the exiting figure).

option name   default value   # description:
"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
"exchange"    false   # whether to exchange x and y axes
"index"       1       # mark index
"type"        2       # mark type
"size"        0.01    # marks size
"max"         nil     # maximum data value
"min"         nil     # minimum data value
"legend"      nil     # legend to annotate the mark type, index, and
                      # size. nil (defalut -- do not to show); a String
                      # as the legend; true to use the name of the GPhys
                      # as the legend
"legend_vx"   nil     # (effective if legend) viewport x values of
                      # the lhs of the legend line (positive float); or
                      # nil for automatic settting (shown to the right of
                      # vpt); or move it to the left relatively (negtive
                      # float)
"legend_vy"   nil     # (effective if legend) viewport y value of the
                      # legend (Float; or nil for automatic settting)
"legend_size" nil     # (effective if legend) character size of the
                      # legend
"map_axes"    false   # [USE IT ONLY WHEN itr=10 (cylindrical)] If
                      # true, draws axes by temprarilly switching to
                      # itr=1 and calling GGraph::axes.
"help"        false   # show help message if true

RETURN VALUE

tone_and_contour(gphys, newframe=true, options=nil)

Calls tone and contour successively. You can specify the options for any of these.

NOTE:

The option keys that are not existent in these methods are simply neglected -- thus no spell-check-like feedback is made, contrary to the indivisual call of contour or tone. Also, only the help menu of tone can be shown.
Requires numru-misc-0.0.6 or later.

contour(gphys, newframe=true, options=nil)

Contour plot by selecting the first 2 dimensions (with GPhys#first2D) if gphys is more than 3D.

Contour levels are determined as follows:

contour levels are set in this method if not set by set_contour_levels or the option "levels" is specified explicitly.
When contour levels are set in this method, the option "levels" has the highest precedence. If it is specified, options "index", "line_type", "label", and "label_height" are used. If "levels" are not specified, contour levels with a linear increment are set by using the options "min", "max", "nlev", "interval", "nozero", "coloring", "clr_min", and "clr_max", which are interpreted by DCLExt::ud_set_linear_levs. The default values of the linear level setting can be changed with set_linear_contour_options.

ARGUMENTS

gphys (GPhys) : a GPhys whose data is plotted.
newframe (true/false) : if true, calls fig, axes (or map), title, and annotate internally; if false, only the poly-line is drawn (overlaid to the exiting figure).

option name   default value   # description:
"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
"transpose"   false   # if true, exchange x and y axes
"exchange"    false   # same as the option transpose
"map_axes"    false   # [USE IT ONLY WHEN itr=10 (cylindrical)] If
                      # true, draws axes by temprarilly switching to
                      # itr=1 and calling GGraph::axes.
"keep"        false   # Use the contour levels used previously
"min"         nil     # minimum contour level
"max"         nil     # maximum contour level
"nlev"        nil     # number of levels
"interval"    nil     # contour interval
"nozero"      nil     # delete zero contour
"coloring"    false   # set color contours with ud_coloring
"clr_min"     13      # (if coloring) minimum color number for the
                      # minimum data values
"clr_max"     99      # (if coloring) maximum color number for the
                      # maximum data values
"help"        false   # show help message if true
"levels"      nil     # contour levels (Array/NArray of Numeric)
"index"       nil     # (if levels) line index(es) (Array/NArray of
                      # integers, Integer, or nil)
"line_type"   nil     # (if levels) line type(s) (Array/NArray of
                      # integers, Integer, or nil)
"label"       nil     # (if levels) contour label(s) (Array/NArray of
                      # String, String, true, false, nil). nil is
                      # recommended.
"label_height"  nil   # (if levels) label height(s)
                      # (Array/NArray of Numeric, Numeric, or nil).
                      #  nil is recommended.

RETURN VALUE

set_contour_levels(options)

Set contour levels for contour explicitly by values with the option levels.

ARGUMENTS

options (Hash) : options to change the default behavior. The option "levels" is mandatory (so it is not optional!). Supported options are "levels", "index", "line_type", "label", and "label_height". See contour for their description.

clear_contour_levels

Clear contour levels set by set_contour_levels.

set_linear_contour_options(options)

Change the default option values regarding linear contour level setting in contour.

ARGUMENTS

options (Hash) : The usage is the same as options for contour but supported options here are limited to "min", "max", "nlev", "interval", "nozero", "coloring", "clr_min", and "clr_max".

RETURN VALUE

a Hash containing the values replaced (the ones before calling this method)

next_linear_contour_options(options)

Similar to set_linear_contour_options but the setting is effective only for the next call of contour.

tone(gphys, newframe=true, options=nil)

Color tone or shading by selecting the first 2 dimensions (with GPhys#first2D) if gphys is more than 3D.

Tone levels are determined as follows:

Tone levels are set in this method if not set by set_tone_levels or the option "levels" (and optionally, "patterns") is (are) specified explicitly.
When contour levels & patterns are set in this method,
- "levels" has the highest precedence. If it is specified, tone levels and patterns are determined by DCLExt::ue_set_tone. Here, tone patterns can be specified with the option "patterns".
- Currently, option "patterns" is effective only if "levels" is specified. Otherwise, it is ignored and patterns are determined internally (by using DCL.uegtlb).
- If not, a linear tone levels are set if "ltone"=true (this is the default), or shading is made if "ltone"=false. Shading is determined by following the parameters in the UDPACK in DCL. Therefore, coloring is made if DCL.udpget('ltone')==true regardless the option "ltone"=false here. When linear levels are set in this method, options "min", "max", "nlev", and "interval" are used if specified, which are interpreted by DCLExt::ue_set_linear_levs. Their default values can be changed by set_linear_tone_options.

ARGUMENTS

gphys (GPhys) : a GPhys whose data is plotted.
newframe (true/false) : if true, calls fig, axes (or map), title, and annotate internally; if false, only the poly-line is drawn (overlaid to the exiting figure).

option name   default value   # description:
"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
"ltone"       true    # Same as udpack parameter ltone
"tonf"        false   # Use DCL.uetonf instead of DCL.uetone
"tonc"        false   # Use DCL.uetonc instead of DCL.uetone
"clr_min"     nil     # if an integer (in 10..99) is specified, used as
                      # the color number for the minimum data values.
                      # (the same can be done by setting the uepack
                      # parameter "icolor1")
"clr_max"     nil     # if an integer (in 10..99) is specified, used as
                      # the color number for the maximum data values.
                      # (the same can be done by setting the uepack
                      # parameter "icolor2")
"transpose"   false   # if true, exchange x and y axes
"exchange"    false   # same as the option transpose
"map_axes"    false   # [USE IT ONLY WHEN itr=10 (cylindrical)] If
                      # true, draws axes by temprarilly switching to
                      # itr=1 and calling GGraph::axes.
"keep"        false   # Use the tone levels and patterns used previously
"min"         nil     # minimum tone level
"max"         nil     # maximum tone level
"nlev"        nil     # number of levels
"interval"    nil     # contour interval
"help"        false   # show help message if true
"levels"      nil     # tone levels  (Array/NArray of Numeric). Works
                      # together with patterns
"patterns"    nil     # tone patters (Array/NArray of Numeric). Works
                      # together with levels

RETURN VALUE

color_bar (options=nil)

Descroption: Draws color bars. Calls DCLext.color_bar.

set_tone_levels(options)

Set tone levels for tone explicitly by values.

ARGUMENTS

options (Hash) : options to change the default behavior. Supported options are "levels" and "patterns". Both of them must be specified explicitly (so they are not optional!).

clear_tone_levels

Clear tone levels set by set_tone_levels.

set_linear_tone_options(options)

Change the default option values regarding linear tone level setting in tone.

ARGUMENTS

options (Hash) : The usage is the same as options for tone but supported options here are limited to "min", "max", "nlev", and "interval".

RETURN VALUE

a Hash containing the values replaced (the ones before calling this method)

next_linear_tone_options(options)

Similar to set_linear_tone_options but the setting is effective only for the next call of tone.

vector(fx, fy, newframe=true, options=nil)

2-D vector plot using DCL_Ext::flow_vect, which scales vectors in physical ("U") coordinates.

ARGUMENTS

fx, fy (GPhys) : represent vectors
newframe (true/false) : if true, calls fig, axes (or map), title, and annotate internally; if false, only the poly-line is drawn (overlaid to the exiting figure).

option name   default value   # description:
"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
"transpose"   false   # if true, exchange x and y axes
"exchange"    false   # same as the option transpose
"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_itr5"   false   # If true, use DCLExt::flow_itr5 to draw
                      # vectors; otherwise, DCLExt::flow_vect or
                      # DCL::ugvect is used.
"keep"        false   # Use the same vector scaling as in the previous
                      # call. -- Currently, works only when "flow_vect"
                      # is true
"xintv"       1       # (Effective only if flow_vect) interval of data
                      # sampling in x
"yintv"       1       # (Effective only if flow_vect) interval of data
                      # sampling in y
"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.
"help"        false   # show help message if true

RETURN VALUE

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

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

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

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

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

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
"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
"title"       nil     # title of the color bar
"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'/'rsizel1'/'rsizec1')
"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