Module: GR

Extended by:
GRCommons::GRCommonUtils, GRCommons::JupyterSupport, GRCommons::SearchSharedLibrary
Defined in:
lib/gr.rb,
lib/gr/ffi.rb,
lib/gr/plot.rb,
lib/gr/grbase.rb,
lib/gr/version.rb

Overview

OverView of GR.rb

+--------------------+  +--------------------+
| GR module          |  | GR3 module         |
| +----------------+ |  | +----------------+ |
| | GR::FFI        | |  | | GR3::FFI       | |
| | +   libGR.so   | |  | | +    libGR3.so | |
| +----------------+ |  | +----------------+ |
|   | define_method  |  |   | define_method  |
| +----------------+ |  | +----------------+ |
| | | GR::GRBase   | |  | | | GR3::GR3Base | |
| | v  (Pri^ate)   | |  | | v  (Pri^ate)   | |
| +++--------------+ |  | +++--------------+ |
|  | Extend          |  |  | Extend          |
|  v                 |  |  v       +-------+ |
|      +-----------+ |  |          | Check | |
|      | GR::Plot  | |  |       <--+ Error | |
|      +-----------+ |  |          +-------+ |
+--------------------+  +----------+---------+
          ^                        ^
          |  +------------------+  |
   Extend |  | GRCommons module |  | Extend
          |  | +--------------+ |  |
          |  | |    Fiddley   | |  |
          |  | +--------------+ |  |
          |  | +--------------+ |  |
          +----+ CommonUtils  +----+
          |  | +--------------+ |  |
          |  | +--------------+ |  |
          +----+    Version   +----+
          |  | +--------------+ |
          |  | +--------------+ |
          +----+JupyterSupport| |
             | +--------------+ |
             +------------------+

(You can edit the above AA diagram with asciiflow.com/))

Fiddley is Ruby-FFI compatible API layer for Fiddle.

The GR module works without Numo::Narrray. GR3 and GR::Plot depends on numo-narray.

This is a procedural interface to the GR plotting library, github.com/sciapp/gr

Defined Under Namespace

Modules: FFI Classes: Error, Plot

Constant Summary collapse

ASF_BUNDLED = 
0
ASF_INDIVIDUAL = 
1
NOCLIP = 
0
CLIP = 
1
COORDINATES_WC = 
0
COORDINATES_NDC = 
1
INTSTYLE_HOLLOW = 
0
INTSTYLE_SOLID = 
1
INTSTYLE_PATTERN = 
2
INTSTYLE_HATCH = 
3
TEXT_HALIGN_NORMAL = 
0
TEXT_HALIGN_LEFT = 
1
TEXT_HALIGN_CENTER = 
2
TEXT_HALIGN_RIGHT = 
3
TEXT_VALIGN_NORMAL = 
0
TEXT_VALIGN_TOP = 
1
TEXT_VALIGN_CAP = 
2
TEXT_VALIGN_HALF = 
3
TEXT_VALIGN_BASE = 
4
TEXT_VALIGN_BOTTOM = 
5
TEXT_PATH_RIGHT = 
0
TEXT_PATH_LEFT = 
1
TEXT_PATH_UP = 
2
TEXT_PATH_DOWN = 
3
TEXT_PRECISION_STRING = 
0
TEXT_PRECISION_CHAR = 
1
TEXT_PRECISION_STROKE = 
2
LINETYPE_SOLID = 
1
LINETYPE_DASHED = 
2
LINETYPE_DOTTED = 
3
LINETYPE_DASHED_DOTTED = 
4
LINETYPE_DASH_2_DOT = 
-1
LINETYPE_DASH_3_DOT = 
-2
LINETYPE_LONG_DASH = 
-3
LINETYPE_LONG_SHORT_DASH = 
-4
LINETYPE_SPACED_DASH = 
-5
LINETYPE_SPACED_DOT = 
-6
LINETYPE_DOUBLE_DOT = 
-7
LINETYPE_TRIPLE_DOT = 
-8
MARKERTYPE_DOT = 
1
MARKERTYPE_PLUS = 
2
MARKERTYPE_ASTERISK = 
3
MARKERTYPE_CIRCLE = 
4
MARKERTYPE_DIAGONAL_CROSS = 
5
MARKERTYPE_SOLID_CIRCLE = 
-1
MARKERTYPE_TRIANGLE_UP = 
-2
MARKERTYPE_SOLID_TRI_UP = 
-3
MARKERTYPE_TRIANGLE_DOWN = 
-4
MARKERTYPE_SOLID_TRI_DOWN = 
-5
MARKERTYPE_SQUARE = 
-6
MARKERTYPE_SOLID_SQUARE = 
-7
MARKERTYPE_BOWTIE = 
-8
MARKERTYPE_SOLID_BOWTIE = 
-9
MARKERTYPE_HOURGLASS = 
-10
MARKERTYPE_SOLID_HGLASS = 
-11
MARKERTYPE_DIAMOND = 
-12
MARKERTYPE_SOLID_DIAMOND = 
-13
MARKERTYPE_STAR = 
-14
MARKERTYPE_SOLID_STAR = 
-15
MARKERTYPE_TRI_UP_DOWN = 
-16
MARKERTYPE_SOLID_TRI_RIGHT = 
-17
MARKERTYPE_SOLID_TRI_LEFT = 
-18
MARKERTYPE_HOLLOW_PLUS = 
-19
MARKERTYPE_SOLID_PLUS = 
-20
MARKERTYPE_PENTAGON = 
-21
MARKERTYPE_HEXAGON = 
-22
MARKERTYPE_HEPTAGON = 
-23
MARKERTYPE_OCTAGON = 
-24
MARKERTYPE_STAR_4 = 
-25
MARKERTYPE_STAR_5 = 
-26
MARKERTYPE_STAR_6 = 
-27
MARKERTYPE_STAR_7 = 
-28
MARKERTYPE_STAR_8 = 
-29
MARKERTYPE_VLINE = 
-30
MARKERTYPE_HLINE = 
-31
MARKERTYPE_OMARK = 
-32
OPTION_X_LOG = 
1
OPTION_Y_LOG = 
2
OPTION_Z_LOG = 
4
OPTION_FLIP_X = 
8
OPTION_FLIP_Y = 
16
OPTION_FLIP_Z = 
32
OPTION_LINES = 
0
OPTION_MESH = 
1
OPTION_FILLED_MESH = 
2
OPTION_Z_SHADED_MESH = 
3
OPTION_COLORED_MESH = 
4
OPTION_CELL_ARRAY = 
5
OPTION_SHADED_MESH = 
6
MODEL_RGB = 
0
MODEL_HSV = 
1
COLORMAP_UNIFORM = 
0
COLORMAP_TEMPERATURE = 
1
COLORMAP_GRAYSCALE = 
2
COLORMAP_GLOWING = 
3
COLORMAP_RAINBOWLIKE = 
4
COLORMAP_GEOLOGIC = 
5
COLORMAP_GREENSCALE = 
6
COLORMAP_CYANSCALE = 
7
COLORMAP_BLUESCALE = 
8
COLORMAP_MAGENTASCALE = 
9
COLORMAP_REDSCALE = 
10
COLORMAP_FLAME = 
11
COLORMAP_BROWNSCALE = 
12
COLORMAP_PILATUS = 
13
COLORMAP_AUTUMN = 
14
COLORMAP_BONE = 
15
COLORMAP_COOL = 
16
COLORMAP_COPPER = 
17
COLORMAP_GRAY = 
18
COLORMAP_HOT = 
19
COLORMAP_HSV = 
20
COLORMAP_JET = 
21
COLORMAP_PINK = 
22
COLORMAP_SPECTRAL = 
23
COLORMAP_SPRING = 
24
COLORMAP_SUMMER = 
25
COLORMAP_WINTER = 
26
COLORMAP_GIST_EARTH = 
27
COLORMAP_GIST_HEAT = 
28
COLORMAP_GIST_NCAR = 
29
COLORMAP_GIST_RAINBOW = 
30
COLORMAP_GIST_STERN = 
31
COLORMAP_AFMHOT = 
32
COLORMAP_BRG = 
33
COLORMAP_BWR = 
34
COLORMAP_COOLWARM = 
35
COLORMAP_CMRMAP = 
36
COLORMAP_CUBEHELIX = 
37
COLORMAP_GNUPLOT = 
38
COLORMAP_GNUPLOT2 = 
39
COLORMAP_OCEAN = 
40
COLORMAP_RAINBOW = 
41
COLORMAP_SEISMIC = 
42
COLORMAP_TERRAIN = 
43
COLORMAP_VIRIDIS = 
44
COLORMAP_INFERNO = 
45
COLORMAP_PLASMA = 
46
COLORMAP_MAGMA = 
47
FONT_TIMES_ROMAN = 
101
FONT_TIMES_ITALIC = 
102
FONT_TIMES_BOLD = 
103
FONT_TIMES_BOLDITALIC = 
104
FONT_HELVETICA = 
105
FONT_HELVETICA_OBLIQUE = 
106
FONT_HELVETICA_BOLD = 
107
FONT_HELVETICA_BOLDOBLIQUE = 
108
FONT_COURIER = 
109
FONT_COURIER_OBLIQUE = 
110
FONT_COURIER_BOLD = 
111
FONT_COURIER_BOLDOBLIQUE = 
112
FONT_SYMBOL = 
113
FONT_BOOKMAN_LIGHT = 
114
FONT_BOOKMAN_LIGHTITALIC = 
115
FONT_BOOKMAN_DEMI = 
116
FONT_BOOKMAN_DEMIITALIC = 
117
FONT_NEWCENTURYSCHLBK_ROMAN = 
118
FONT_NEWCENTURYSCHLBK_ITALIC = 
119
FONT_NEWCENTURYSCHLBK_BOLD = 
120
FONT_NEWCENTURYSCHLBK_BOLDITALIC = 
121
FONT_AVANTGARDE_BOOK = 
122
FONT_AVANTGARDE_BOOKOBLIQUE = 
123
FONT_AVANTGARDE_DEMI = 
124
FONT_AVANTGARDE_DEMIOBLIQUE = 
125
FONT_PALATINO_ROMAN = 
126
FONT_PALATINO_ITALIC = 
127
FONT_PALATINO_BOLD = 
128
FONT_PALATINO_BOLDITALIC = 
129
FONT_ZAPFCHANCERY_MEDIUMITALIC = 
130
FONT_ZAPFDINGBATS = 
131

'ps'

'eps'

'pdf'

'pgf'

'bmp'

'jpeg'

'jpg'

'png'

'tiff'

'tif'

'fig'

'svg'

'wmf'
PATH_STOP = 
0x00
PATH_MOVETO = 
0x01
PATH_LINETO = 
0x02
PATH_CURVE3 = 
0x03
PATH_CURVE4 = 
0x04
PATH_CLOSEPOLY = 
0x4f
MPL_SUPPRESS_CLEAR = 
1
MPL_POSTPONE_UPDATE = 
2
XFORM_BOOLEAN = 
0
XFORM_LINEAR = 
1
XFORM_LOG = 
2
XFORM_LOGLOG = 
3
XFORM_CUBIC = 
4
XFORM_EQUALIZED = 
5
ENCODING_LATIN1 = 
300
ENCODING_UTF8 = 
301
UPSAMPLE_VERTICAL_DEFAULT = 
0x00000000
UPSAMPLE_HORIZONTAL_DEFAULT = 
0x00000000
DOWNSAMPLE_VERTICAL_DEFAULT = 
0x00000000
DOWNSAMPLE_HORIZONTAL_DEFAULT = 
0x00000000
UPSAMPLE_VERTICAL_NEAREST = 
0x00000001
UPSAMPLE_HORIZONTAL_NEAREST = 
0x00000100
DOWNSAMPLE_VERTICAL_NEAREST = 
0x00010000
DOWNSAMPLE_HORIZONTAL_NEAREST = 
0x01000000
UPSAMPLE_VERTICAL_LINEAR = 
0x00000002
UPSAMPLE_HORIZONTAL_LINEAR = 
0x00000200
DOWNSAMPLE_VERTICAL_LINEAR = 
0x00020000
DOWNSAMPLE_HORIZONTAL_LINEAR = 
0x02000000
UPSAMPLE_VERTICAL_LANCZOS = 
0x00000003
UPSAMPLE_HORIZONTAL_LANCZOS = 
0x00000300
DOWNSAMPLE_VERTICAL_LANCZOS = 
0x00030000
DOWNSAMPLE_HORIZONTAL_LANCZOS = 
0x03000000
RESAMPLE_DEFAULT = 
(UPSAMPLE_VERTICAL_DEFAULT | UPSAMPLE_HORIZONTAL_DEFAULT |
DOWNSAMPLE_VERTICAL_DEFAULT | DOWNSAMPLE_HORIZONTAL_DEFAULT)
RESAMPLE_NEAREST = 
(UPSAMPLE_VERTICAL_NEAREST | UPSAMPLE_HORIZONTAL_NEAREST |
DOWNSAMPLE_VERTICAL_NEAREST | DOWNSAMPLE_HORIZONTAL_NEAREST)
RESAMPLE_LINEAR = 
(UPSAMPLE_VERTICAL_LINEAR | UPSAMPLE_HORIZONTAL_LINEAR |
DOWNSAMPLE_VERTICAL_LINEAR | DOWNSAMPLE_HORIZONTAL_LINEAR)
RESAMPLE_LANCZOS = 
(UPSAMPLE_VERTICAL_LANCZOS | UPSAMPLE_HORIZONTAL_LANCZOS |
DOWNSAMPLE_VERTICAL_LANCZOS | DOWNSAMPLE_HORIZONTAL_LANCZOS)
PROJECTION_DEFAULT = 
0
PROJECTION_ORTHOGRAPHIC = 
1
PROJECTION_PERSPECTIVE = 
2
VERSION = 
GRCommons::VERSION

Constants included from GRCommons::GRCommonUtils

GRCommons::GRCommonUtils::SUPPORTED_TYPES

Class Attribute Summary collapse

Class Method Summary collapse

Methods included from GRCommons::SearchSharedLibrary

recursive_search, search_shared_library

Methods included from GRCommons::GRCommonUtils

create_ffi_pointer, double, equal_length, float, inquiry, inquiry_double, inquiry_int, inquiry_uint, int, narray?, read_ffi_pointer, uint, uint16, uint8

Methods included from GRCommons::JupyterSupport

extended, show

Class Attribute Details

.ffi_lib ⇒ Object

Returns the value of attribute ffi_lib.



52
53
54
 
# File 'lib/gr.rb', line 52

def ffi_lib
  @ffi_lib
end

Class Method Details

._contour_ ⇒ Object

Draw contours of a three-dimensional data set whose values are specified over a rectangular mesh. Contour lines may optionally be labeled.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • h (Array, NArray) —

    A list containing the Z coordinate for the height values

  • z (Array, NArray) —

    A list containing the Z coordinate for the height values A list of length ‘len(x)` * `len(y)` or an appropriately dimensioned array containing the Z coordinates

  • major_h (Integer) —

    Directs GR to label contour lines. For example, a value of 3 would label every third line. A value of 1 will label every line. A value of 0 produces no labels. To produce colored contour lines, add an offset of 1000 to major_h.



1243
1244
1245
1246
1247
1248
1249
 
# File 'lib/gr/plot.rb', line 1243

def contour(x, y, h, z, major_h)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  nh = h.length
  super(nx, ny, nh, x, y, h, z, major_h)
end

._contourf_ ⇒ Object

Draw filled contours of a three-dimensional data set whose values are specified over a rectangular mesh.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • h (Array, NArray) —

    A list containing the Z coordinate for the height values or the number of contour lines which will be evenly distributed between minimum and maximum Z value

  • z (Array, NArray) —

    A list of length ‘len(x)` * `len(y)` or an appropriately dimensioned array containing the Z coordinates



1249
1250
1251
1252
1253
1254
1255
 
# File 'lib/gr/plot.rb', line 1249

def contourf(x, y, h, z, major_h)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  nh = h.length
  super(nx, ny, nh, x, y, h, z, major_h)
end

._hexbin_ ⇒ Integer

Returns:

  • (Integer) 


1255
1256
1257
1258
 
# File 'lib/gr/plot.rb', line 1255

def hexbin(x, y, nbins)
  n = x.length
  super(n, x, y, nbins)
end

._shade_ ⇒ Object 



1297
1298
1299
 
# File 'lib/gr/plot.rb', line 1297

def shade(*)
  super
end

._surface_ ⇒ Object

Draw a three-dimensional surface plot for the given data points. x and y define a grid. z is a singly dimensioned array containing at least nx * ny data points. Z describes the surface height at each point on the grid. Data is ordered as shown in the table: (Plot) Draw a three-dimensional surface plot.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • z (Array, NArray) —

    A list of length ‘len(x)` * `len(y)` or an appropriately dimensioned array containing the Z coordinates

  • option (Integer) —

    Surface display option

    • 0 LINES

      • Use X Y polylines to denote the surface

    • 1 MESH

      • Use a wire grid to denote the surface

    • 2 FILLED_MESH

      • Applies an opaque grid to the surface

    • 3 Z_SHADED_MESH

      • Applies Z-value shading to the surface

    • 4 COLORED_MESH

      • Applies a colored grid to the surface

    • 5 CELL_ARRAY

      • Applies a grid of individually-colored cells to the surface

    • 6 SHADED_MESH

      • Applies light source shading to the 3-D surface



1272
1273
1274
1275
1276
1277
 
# File 'lib/gr/plot.rb', line 1272

def surface(x, y, z, option)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  super(nx, ny, x, y, z, option)
end

.activatews ⇒ Object

Activate the specified workstation.

Parameters:

  • workstation_id (Integer) —

    A workstation identifier.



147
148
149
 
# File 'lib/gr.rb', line 147

def activatews(*)
  super
end

.adjustlimits(amin, amax) ⇒ Object 



1218
1219
1220
1221
1222
1223
1224
 
# File 'lib/gr.rb', line 1218

def adjustlimits(amin, amax)
  inquiry i[double double] do |pamin, pamax|
    pamin.write_double amin
    pamax.write_double amax
    super(pamin, pamax)
  end
end

.adjustrange(amin, amax) ⇒ Object 



1226
1227
1228
1229
1230
1231
1232
 
# File 'lib/gr.rb', line 1226

def adjustrange(amin, amax)
  inquiry i[double double] do |pamin, pamax|
    pamin.write_double amin
    pamax.write_double amax
    super(pamin, pamax)
  end
end

.axes ⇒ Object Also known as: axes2d

Draw X and Y coordinate axes with linearly and/or logarithmically spaced tick marks.

Parameters:

  • x_tick (Numeric) —

    The interval between minor tick marks on the X axis.

  • y_tick (Numeric) —

    The interval between minor tick marks on the Y axis.

  • x_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the X axis.

  • y_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the Y axis.

  • major_x (Integer) —

    Unitless integer values specifying the number of minor tick intervals between major tick marks. Values of 0 or 1 imply no minor ticks. Negative values specify no labels will be drawn for the associated axis.

  • major_y (Integer) —

    Unitless integer values specifying the number of minor tick intervals between major tick marks. Values of 0 or 1 imply no minor ticks. Negative values specify no labels will be drawn for the associated axis.

  • tick_size (Numeric) —

    The length of minor tick marks specified in a normalized device coordinate unit. Major tick marks are twice as long as minor tick marks. A negative value reverses the tick marks on the axes from inward facing to outward facing (or vice versa).



940
941
942
 
# File 'lib/gr.rb', line 940

def axes(*)
  super
end

.axes3d ⇒ Object

Draw X, Y and Z coordinate axes with linearly and/or logarithmically spaced tick marks. Tick marks are positioned along each axis so that major tick marks fall on the axes origin (whether visible or not). Major tick marks are labeled with the corresponding data values. Axes are drawn according to the scale of the window. Axes and tick marks are drawn using solid lines; line color and width can be modified using the setlinetype and setlinewidth functions. Axes are drawn according to the linear or logarithmic transformation established by the setscale function.

Parameters:

  • x_tick (Numeric) —

    The interval between minor tick marks on the X axis.

  • y_tick (Numeric) —

    The interval between minor tick marks on the Y axis.

  • z_tick (Numeric) —

    The interval between minor tick marks on the Z axis.

  • x_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the X axes.

  • y_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the Y axes.

  • z_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the Z axes.

  • major_x (Integer) —

    Unitless integer values specifying the number of minor tick intervals between major tick marks. Values of 0 or 1 imply no minor ticks. Negative values specify no labels will be drawn for the associated axis.

  • major_y (Integer) —

    Unitless integer values specifying the number of minor tick intervals between major tick marks. Values of 0 or 1 imply no minor ticks. Negative values specify no labels will be drawn for the associated axis.

  • major_z (Integer) —

    Unitless integer values specifying the number of minor tick intervals between major tick marks. Values of 0 or 1 imply no minor ticks. Negative values specify no labels will be drawn for the associated axis.

  • tick_size (Numeric) —

    The length of minor tick marks specified in a normalized device coordinate unit. Major tick marks are twice as long as minor tick marks. A negative value reverses the tick marks on the axes from inward facing to outward facing (or vice versa).



1069
1070
1071
 
# File 'lib/gr.rb', line 1069

def axes3d(*)
  super
end

.axeslbl ⇒ Object 



946
947
948
 
# File 'lib/gr.rb', line 946

def axeslbl(*)
  super
end

.barplot(labels, heights, kv = {}) ⇒ Object

(Plot) Draw a bar plot.



1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
 
# File 'lib/gr/plot.rb', line 1311

def barplot(labels, heights, kv = {})
  labels = labels.map(&:to_s)
  wc, hc = barcoordinates(heights)
  create_plot(:bar, labels, heights, kv) do |plt|
    if kv[:horizontal]
      plt.args = [[hc, wc, nil, nil, '']]
      plt.kvs[:yticks] = [1, 1]
      plt.kvs[:yticklabels] = labels
    else
      plt.args = [[wc, hc, nil, nil, '']]
      plt.kvs[:xticks] = [1, 1]
      plt.kvs[:xticklabels] = labels
    end
  end
end

.begingraphics ⇒ Object

Open a file for graphics output. begingraphics allows to write all graphics output into a XML-formatted file until the endgraphics functions is called. The resulting file may later be imported with the importgraphics function.

Parameters:

  • path (String) —

    Filename for the graphics file.



1502
1503
1504
 
# File 'lib/gr.rb', line 1502

def begingraphics(*)
  super
end

.beginprint ⇒ Object

Open and activate a print device. beginprint opens an additional graphics output device. The device type is obtained from the given file extension.

Parameters:

  • pathname (String) —

    Filename for the print device. The following file types are supported:

    • .ps, .eps : PostScript

    • .pdf : Portable Document Format

    • .bmp : Windows Bitmap (BMP)

    • .jpeg, .jpg : JPEG image file

    • .png : Portable Network Graphics file (PNG)

    • .tiff, .tif : Tagged Image File Format (TIFF)

    • .fig : Xfig vector graphics file

    • .svg : Scalable Vector Graphics

    • .wmf : Windows Metafile



1248
1249
1250
 
# File 'lib/gr.rb', line 1248

def beginprint(*)
  super
end

.beginprintext ⇒ Object

Open and activate a print device with the given layout attributes.

Parameters:

  • pathname (String) —

    Filename for the print device.

  • mode (String) —

    Output mode (Color, GrayScale)

  • fmt (String) —

    Output format The available formats are:

    • A4 : 0.210 x 0.297

    • B5 : 0.176 x 0.250

    • Letter : 0.216 x 0.279

    • Legal : 0.216 x 0.356

    • Executive : 0.191 x 0.254

    • A0 : 0.841 x 1.189

    • A1 : 0.594 x 0.841

    • A2 : 0.420 x 0.594

    • A3 : 0.297 x 0.420

    • A5 : 0.148 x 0.210

    • A6 : 0.105 x 0.148

    • A7 : 0.074 x 0.105

    • A8 : 0.052 x 0.074

    • A9 : 0.037 x 0.052

    • B0 : 1.000 x 1.414

    • B1 : 0.500 x 0.707

    • B10 : 0.031 x 0.044

    • B2 : 0.500 x 0.707

    • B3 : 0.353 x 0.500

    • B4 : 0.250 x 0.353

    • B6 : 0.125 x 0.176

    • B7 : 0.088 x 0.125

    • B8 : 0.062 x 0.088

    • B9 : 0.044 x 0.062

    • C5E : 0.163 x 0.229

    • Comm10E : 0.105 x 0.241

    • DLE : 0.110 x 0.220

    • Folio : 0.210 x 0.330

    • Ledger : 0.432 x 0.279

    • Tabloid : 0.279 x 0.432

  • orientation (String) —

    Page orientation (Landscape, Portait)



1288
1289
1290
 
# File 'lib/gr.rb', line 1288

def beginprintext(*)
  super
end

.beginselection ⇒ Object 



1536
1537
1538
 
# File 'lib/gr.rb', line 1536

def beginselection(*)
  super
end

.camerainteraction ⇒ Object

Interface for interaction with the rotation of the model. For this a virtual Arcball is used.

Parameters:

  • start_mouse_pos_x (Numeric) —

    x component of the start mouse position

  • start_mouse_pos_y (Numeric) —

    y component of the start mouse position

  • end_mouse_pos_x (Numeric) —

    x component of the end mouse position

  • end_mouse_pos_y (Numeric) —

    y component of the end mouse position



1946
1947
1948
 
# File 'lib/gr.rb', line 1946

def camerainteraction(*)
  super
end

.cellarray(xmin, xmax, ymin, ymax, dimx, dimy, color) ⇒ Object

Display rasterlike images in a device-independent manner. The cell array function partitions a rectangle given by two corner points into DIMX X DIMY cells, each of them colored individually by the corresponding color index of the given cell array. The values for xmin, xmax, ymin and ymax are in world coordinates.

Parameters:

  • xmin (Numeric) —

    Lower left point of the rectangle

  • ymin (Numeric) —

    Lower left point of the rectangle

  • xmax (Numeric) —

    Upper right point of the rectangle

  • ymax (Numeric) —

    Upper right point of the rectangle

  • dimx (Integer) —

    X dimension of the color index array

  • dimy (Integer) —

    Y dimension of the color index array

  • color (Array, NArray) —

    Color index array



229
230
231
 
# File 'lib/gr.rb', line 229

def cellarray(xmin, xmax, ymin, ymax, dimx, dimy, color)
  super(xmin, xmax, ymin, ymax, dimx, dimy, 1, 1, dimx, dimy, int(color))
end

.clearws ⇒ Object 



161
162
163
 
# File 'lib/gr.rb', line 161

def clearws(*)
  super
end

.closegks ⇒ Object 



95
96
97
 
# File 'lib/gr.rb', line 95

def closegks(*)
  super
end

.closeseg ⇒ Object 



791
792
793
 
# File 'lib/gr.rb', line 791

def closeseg(*)
  super
end

.closews ⇒ Object

Close the specified workstation.

Parameters:

  • workstation_id (Integer) —

    A workstation identifier.



141
142
143
 
# File 'lib/gr.rb', line 141

def closews(*)
  super
end

.colorbar ⇒ Object 



1187
1188
1189
 
# File 'lib/gr.rb', line 1187

def colorbar(*)
  super
end

.configurews ⇒ Object 



157
158
159
 
# File 'lib/gr.rb', line 157

def configurews(*)
  super
end

.contour(*args) ⇒ Object

(Plot) Draw a contour plot.



1127
1128
1129
1130
1131
1132
1133
 
# File 'lib/gr.rb', line 1127

def contour(x, y, h, z, major_h)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  nh = h.length
  super(nx, ny, nh, x, y, h, z, major_h)
end

.contourf(*args) ⇒ Object

(Plot) Draw a filled contour plot.



1146
1147
1148
1149
1150
1151
1152
 
# File 'lib/gr.rb', line 1146

def contourf(x, y, h, z, major_h)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  nh = h.length
  super(nx, ny, nh, x, y, h, z, major_h)
end

.copysegws ⇒ Object 



779
780
781
 
# File 'lib/gr.rb', line 779

def copysegws(*)
  super
end

.createseg ⇒ Object 



775
776
777
 
# File 'lib/gr.rb', line 775

def createseg(*)
  super
end

.deactivatews ⇒ Object

Deactivate the specified workstation.

Parameters:

  • workstation_id (Integer) —

    A workstation identifier.



153
154
155
 
# File 'lib/gr.rb', line 153

def deactivatews(*)
  super
end

.delaunay(x, y) ⇒ Object 



1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
 
# File 'lib/gr.rb', line 1593

def delaunay(x, y)
  # Feel free to make a pull request if you catch a mistake
  # or you have an idea to improve it.
  npoints = equal_length(x, y)
  triangles = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T)
  dim = 3
  n_tri = inquiry_int do |ntri|
    super(npoints, x, y, ntri, triangles.ref)
  end
  if n_tri > 0
    tri = triangles.to_str(dim * n_tri * Fiddle::SIZEOF_INT).unpack('l*') # Int32
    # Ruby  : 0-based indexing
    # Julia : 1-based indexing
    tri = tri.each_slice(dim).to_a
    [n_tri, tri]
  else
    0
  end
end

.destroycontext ⇒ Object 



1584
1585
1586
 
# File 'lib/gr.rb', line 1584

def destroycontext(*)
  super
end

.drawarc ⇒ Object

Draw a circular or elliptical arc covering the specified rectangle. The resulting arc begins at a1 and ends at a2 degrees. Angles are interpreted such that 0 degrees is at the 3 o’clock position. The center of the arc is the center of the given rectangle.

Parameters:

  • xmin (Numeric) —

    Lower left edge of the rectangle

  • xmax (Numeric) —

    Lower right edge of the rectangle

  • ymin (Numeric) —

    Upper left edge of the rectangle

  • ymax (Numeric) —

    Upper right edge of the rectangle

  • a1 (Numeric) —

    The start angle

  • a2 (Numeric) —

    The end angle



1349
1350
1351
 
# File 'lib/gr.rb', line 1349

def drawarc(*)
  super
end

.drawarrow ⇒ Object

Draw an arrow between two points. Different arrow styles (angles between arrow tail and wing, optionally filled heads, double headed arrows) are available and can be set with the setarrowstyle function.

Parameters:

  • x1 (Numeric) —

    Starting point of the arrow (tail)

  • y1 (Numeric) —

    Starting point of the arrow (tail)

  • x2 (Numeric) —

    Head of the arrow

  • y2 (Numeric) —

    Head of the arrow



1424
1425
1426
 
# File 'lib/gr.rb', line 1424

def drawarrow(*)
  super
end

.drawgraphics ⇒ Integer

Returns:

  • (Integer) 


1516
1517
1518
 
# File 'lib/gr.rb', line 1516

def drawgraphics(*)
  super
end

.drawimage(xmin, xmax, ymin, ymax, width, height, data, model = 0) ⇒ Object

Draw an image into a given rectangular area. The points (xmin, ymin) and (xmax, ymax) are world coordinates defining diagonally opposite corner points of a rectangle. This rectangle is divided into width by height cells. The two-dimensional array data specifies colors for each cell.

Parameters:

  • xmin (Numeric) —

    First corner point of the rectangle

  • ymin (Numeric) —

    First corner point of the rectangle

  • xmax (Numeric) —

    Second corner point of the rectangle

  • ymax (Numeric) —

    Second corner point of the rectangle

  • width (Integer) —

    The width and the height of the image

  • height (Integer) —

    The width and the height of the image

  • data (Array, NArray) —

    An array of color values dimensioned width by height

  • model (Integer) (defaults to: 0) —

    Color model ( default = 0 ) The available color models are:

    • 0 : MODEL_RGB

      • AABBGGRR

    • 1 : MODEL_HSV

      • AAVVSSHH



1459
1460
1461
 
# File 'lib/gr.rb', line 1459

def drawimage(xmin, xmax, ymin, ymax, width, height, data, model = 0)
  super(xmin, xmax, ymin, ymax, width, height, uint(data), model)
end

.drawpath(points, codes, fill) ⇒ Object

Draw simple and compound outlines consisting of line segments and bezier curves.

Parameters:

  • points (Array, NArray) —

    (N, 2) array of (x, y) vertices



1377
1378
1379
1380
 
# File 'lib/gr.rb', line 1377

def drawpath(points, codes, fill)
  len = codes.length
  super(len, points, uint8(codes), fill)
end

.drawrect ⇒ Object

Draw a rectangle using the current line attributes.

Parameters:

  • xmin (Numeric) —

    Lower left edge of the rectangle

  • xmax (Numeric) —

    Lower right edge of the rectangle

  • ymin (Numeric) —

    Upper left edge of the rectangle

  • ymax (Numeric) —

    Upper right edge of the rectangle



1326
1327
1328
 
# File 'lib/gr.rb', line 1326

def drawrect(*)
  super
end

.emergencyclosegks ⇒ Object 



795
796
797
 
# File 'lib/gr.rb', line 795

def emergencyclosegks(*)
  super
end

.endgraphics ⇒ Object 



1506
1507
1508
 
# File 'lib/gr.rb', line 1506

def endgraphics(*)
  super
end

.endprint ⇒ Object 



1292
1293
1294
 
# File 'lib/gr.rb', line 1292

def endprint(*)
  super
end

.endselection ⇒ Object 



1540
1541
1542
 
# File 'lib/gr.rb', line 1540

def endselection(*)
  super
end

.fillarc ⇒ Object

Fill a circular or elliptical arc covering the specified rectangle. The resulting arc begins at a1 and ends at a2 degrees. Angles are interpreted such that 0 degrees is at the 3 o’clock position. The center of the arc is the center of the given rectangle.

Parameters:

  • xmin (Numeric) —

    Lower left edge of the rectangle

  • xmax (Numeric) —

    Lower right edge of the rectangle

  • ymin (Numeric) —

    Upper left edge of the rectangle

  • ymax (Numeric) —

    Upper right edge of the rectangle

  • a1 (Numeric) —

    The start angle

  • a2 (Numeric) —

    The end angle



1363
1364
1365
 
# File 'lib/gr.rb', line 1363

def fillarc(*)
  super
end

.fillarea(x, y) ⇒ Object

Allows you to specify a polygonal shape of an area to be filled. The attributes that control the appearance of fill areas are fill area interior style, fill area style index and fill area color index.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates



211
212
213
214
 
# File 'lib/gr.rb', line 211

def fillarea(x, y)
  n = equal_length(x, y)
  super(n, x, y)
end

.fillrect ⇒ Object

Draw a filled rectangle using the current fill attributes.

Parameters:

  • xmin (Numeric) —

    Lower left edge of the rectangle

  • xmax (Numeric) —

    Lower right edge of the rectangle

  • ymin (Numeric) —

    Upper left edge of the rectangle

  • ymax (Numeric) —

    Upper right edge of the rectangle



1335
1336
1337
 
# File 'lib/gr.rb', line 1335

def fillrect(*)
  super
end

.gdp(x, y, primid, datrec) ⇒ Object

Generates a generalized drawing primitive (GDP) of the type you specify, using specified points and any additional information contained in a data record.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • primid (Integer) —

    Primitive identifier

  • datrec (Array, NArray) —

    Primitive data record



275
276
277
278
279
 
# File 'lib/gr.rb', line 275

def gdp(x, y, primid, datrec)
  n = equal_length(x, y)
  ldr = datrec.length
  super(n, x, y, primid, ldr, datrec)
end

.getgraphics ⇒ String

Returns:

  • (String) 


1511
1512
1513
 
# File 'lib/gr.rb', line 1511

def getgraphics(*)
  super.to_s
end

.gradient(x, y, z) ⇒ Object

Deprecated. 


1632
1633
1634
1635
1636
1637
1638
1639
 
# File 'lib/gr.rb', line 1632

def gradient(x, y, z)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  inquiry [{ double: nx * ny }, { double: nx * ny }] do |pu, pv|
    super(nx, ny, x, y, z, pu, pv)
  end
end

.grid ⇒ Object

Draw a linear and/or logarithmic grid. Major grid lines correspond to the axes origin and major tick marks whether visible or not. Minor grid lines are drawn at points equal to minor tick marks. Major grid lines are drawn using black lines and minor grid lines are drawn using gray lines.

Parameters:

  • x_tick (Numeric) —

    The length in world coordinates of the interval between minor grid lines.

  • y_tick (Numeric) —

    The length in world coordinates of the interval between minor grid lines.

  • x_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the grid.

  • y_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the grid.

  • major_x (Integer) —

    Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.

  • major_y (Integer) —

    Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.



965
966
967
 
# File 'lib/gr.rb', line 965

def grid(*)
  super
end

.grid3d ⇒ Object

Draw a linear and/or logarithmic grid. Major grid lines correspond to the axes origin and major tick marks whether visible or not. Minor grid lines are drawn at points equal to minor tick marks. Major grid lines are drawn using black lines and minor grid lines are drawn using gray lines.

Parameters:

  • x_tick (Numeric) —

    The length in world coordinates of the interval between minor grid lines.

  • y_tick (Numeric) —

    The length in world coordinates of the interval between minor grid lines.

  • z_tick (Numeric) —

    The length in world coordinates of the interval between minor grid lines.

  • x_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the grid.

  • y_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the grid.

  • z_org (Numeric) —

    The world coordinates of the origin (point of intersection) of the grid.

  • major_x (Integer) —

    Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.

  • major_y (Integer) —

    Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.

  • major_z (Integer) —

    Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.



989
990
991
 
# File 'lib/gr.rb', line 989

def grid3d(*)
  super
end

.gridit(xd, yd, zd, nx, ny) ⇒ Object 



298
299
300
301
302
303
 
# File 'lib/gr.rb', line 298

def gridit(xd, yd, zd, nx, ny)
  nd = equal_length(xd, yd, zd)
  inquiry [{ double: nx }, { double: ny }, { double: nx * ny }] do |px, py, pz|
    super(nd, xd, yd, zd, nx, ny, px, py, pz)
  end
end

.heatmap(*args) ⇒ Object

(Plot) Draw a heatmap.



1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
 
# File 'lib/gr/plot.rb', line 1215

def heatmap(*args)
  # FIXME
  args, kv = format_xyzc(*args)
  _x, _y, z = args
  ysize, xsize = z.shape
  z = z.reshape(xsize, ysize)
  create_plot(:heatmap, kv) do |plt|
    plt.kvs[:xlim] ||= [0.5, xsize + 0.5]
    plt.kvs[:ylim] ||= [0.5, ysize + 0.5]
    plt.args = [[(1..xsize).to_a, (1..ysize).to_a, z, nil, '']]
  end
end

.herrorbars(x, y, e1, e2) ⇒ Object

Draw a standard horizontal error bar graph.

Parameters:

  • x (Array, NArray) —

    A list of length N containing the X coordinates

  • y (Array, NArray) —

    A list of length N containing the Y coordinates

  • e1 (Array, NArray) —

    The absolute values of the lower error bar data

  • e2 (Array, NArray) —

    The absolute values of the lower error bar data



1008
1009
1010
1011
 
# File 'lib/gr.rb', line 1008

def herrorbars(x, y, e1, e2)
  n = equal_length(x, y, e1, e2)
  super(n, x, y, e1, e2)
end

.hexbin(*args) ⇒ Object

(Plot) Draw a hexagon binning plot.



1162
1163
1164
1165
 
# File 'lib/gr.rb', line 1162

def hexbin(x, y, nbins)
  n = x.length
  super(n, x, y, nbins)
end

.histogram(series, kv = {}) ⇒ Object

(Plot) Draw a histogram.



1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
 
# File 'lib/gr/plot.rb', line 1328

def histogram(series, kv = {})
  create_plot(:hist, series, kv) do |plt|
    nbins = plt.kvs[:nbins] || 0
    x, y = hist(series, nbins)
    plt.args = if kv[:horizontal]
                 [[y, x, nil, nil, '']]
               else
                 [[x, y, nil, nil, '']]
               end
  end
end

.hold(flag = true) ⇒ Object 



1356
1357
1358
1359
 
# File 'lib/gr/plot.rb', line 1356

def hold(flag = true)
  plt = GR::Plot.last_plot
  plt.kvs.slice(:window, :scale, :xaxis, :yaxis, :zaxis).merge({ ax: flag, clear: !flag })
end

.hsvtorgb(h, s, v) ⇒ Object 



1202
1203
1204
1205
1206
 
# File 'lib/gr.rb', line 1202

def hsvtorgb(h, s, v)
  inquiry i[double double double] do |r, g, b|
    super(h, s, v, r, g, b)
  end
end

.importgraphics ⇒ Integer

Returns:

  • (Integer) 


1464
1465
1466
 
# File 'lib/gr.rb', line 1464

def importgraphics(*)
  super
end

.imshow(img, kv = {}) ⇒ Object

(Plot) Draw an image.



1341
1342
1343
1344
1345
1346
 
# File 'lib/gr/plot.rb', line 1341

def imshow(img, kv = {})
  img = Numo::DFloat.cast(img) # Umm...
  create_plot(:imshow, img, kv) do |plt|
    plt.args = [[nil, nil, img, nil, '']]
  end
end

.initgr ⇒ Object 



87
88
89
 
# File 'lib/gr.rb', line 87

def initgr(*)
  super
end

.inqbbox ⇒ Object 



1552
1553
1554
1555
1556
 
# File 'lib/gr.rb', line 1552

def inqbbox
  inquiry i[double double double double] do |*pts|
    super(*pts)
  end
end

.inqbordercolorind ⇒ Object 



1860
1861
1862
 
# File 'lib/gr.rb', line 1860

def inqbordercolorind
  inquiry_int { |pt| super(pt) }
end

.inqborderwidth ⇒ Object 



1850
1851
1852
 
# File 'lib/gr.rb', line 1850

def inqborderwidth
  inquiry_double { |pt| super(pt) }
end

.inqcharheight ⇒ Object

Gets the current character height. This function gets the height of text output primitives. Text height is defined as a percentage of the default window. GR uses the default text height of 0.027 (2.7% of the height of the default window).



565
566
567
 
# File 'lib/gr.rb', line 565

def inqcharheight
  inquiry_double { |pt| super(pt) }
end

.inqcolor(color) ⇒ Object 



1191
1192
1193
1194
1195
 
# File 'lib/gr.rb', line 1191

def inqcolor(color)
  inquiry_int do |rgb|
    super(color, rgb)
  end
end

.inqcolorfromrgb ⇒ Integer

Returns:

  • (Integer) 


1198
1199
1200
 
# File 'lib/gr.rb', line 1198

def inqcolorfromrgb(*)
  super
end

.inqcolormap ⇒ Object

inqcolormap



1172
1173
1174
 
# File 'lib/gr.rb', line 1172

def inqcolormap
  inquiry_int { |pt| super(pt) }
end

.inqdspsize ⇒ Object

inqdspsize



100
101
102
103
104
 
# File 'lib/gr.rb', line 100

def inqdspsize
  inquiry i[double double int int] do |*pts|
    super(*pts)
  end
end

.inqfillcolorind ⇒ Object

Returns the current fill area color index.



666
667
668
 
# File 'lib/gr.rb', line 666

def inqfillcolorind
  inquiry_int { |pt| super(pt) }
end

.inqfillintstyle ⇒ Object

Returns the fill area interior style to be used for fill areas.



637
638
639
 
# File 'lib/gr.rb', line 637

def inqfillintstyle
  inquiry_int { |pt| super(pt) }
end

.inqfillstyle ⇒ Object

Returns the current fill area color index.



653
654
655
 
# File 'lib/gr.rb', line 653

def inqfillstyle
  inquiry_int { |pt| super(pt) }
end

.inqlinecolorind ⇒ Object

inqlinecolorind



360
361
362
 
# File 'lib/gr.rb', line 360

def inqlinecolorind
  inquiry_int { |pt| super(pt) }
end

.inqlinetype ⇒ Object 



335
336
337
 
# File 'lib/gr.rb', line 335

def inqlinetype
  inquiry_int { |pt| super(pt) }
end

.inqlinewidth ⇒ Object 



349
350
351
 
# File 'lib/gr.rb', line 349

def inqlinewidth
  inquiry_double { |pt| super(pt) }
end

.inqmarkercolorind ⇒ Object 



468
469
470
 
# File 'lib/gr.rb', line 468

def inqmarkercolorind
  inquiry_int { |pt| super(pt) }
end

.inqmarkersize ⇒ Object

Inquire the marker size for polymarkers.



458
459
460
 
# File 'lib/gr.rb', line 458

def inqmarkersize
  inquiry_double { |pt| super(pt) }
end

.inqmarkertype ⇒ Object 



445
446
447
 
# File 'lib/gr.rb', line 445

def inqmarkertype
  inquiry_int { |pt| super(pt) }
end

.inqmathtex(x, y, string) ⇒ Object

inqmathtex



1530
1531
1532
1533
1534
 
# File 'lib/gr.rb', line 1530

def inqmathtex(x, y, string)
  inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
    super(x, y, string, tbx, tby)
  end
end

.inqorthographicprojection ⇒ Object

Return the camera position, up vector and focus point.



1934
1935
1936
1937
1938
 
# File 'lib/gr.rb', line 1934

def inqorthographicprojection
  inquiry([:double] * 6) do |*pts|
    super(*pts)
  end
end

.inqperspectiveprojection ⇒ Object

Return the parameters for the perspective projection.



1915
1916
1917
1918
1919
 
# File 'lib/gr.rb', line 1915

def inqperspectiveprojection
  inquiry i[double double double] do |*pts|
    super(*pts)
  end
end

.inqprojectiontype ⇒ Object

Return the projection type.



1878
1879
1880
 
# File 'lib/gr.rb', line 1878

def inqprojectiontype
  inquiry_int { |pt| super(pt) }
end

.inqregenflags ⇒ Integer

Returns:

  • (Integer) 


1568
1569
1570
 
# File 'lib/gr.rb', line 1568

def inqregenflags(*)
  super
end

.inqresamplemethod ⇒ Object

Inquire the resample method used for gr.drawimage().



1807
1808
1809
1810
1811
 
# File 'lib/gr.rb', line 1807

def inqresamplemethod
  inquiry_uint do |resample_method|
    super(resample_method)
  end
end

.inqscale ⇒ Object

inqscale



855
856
857
 
# File 'lib/gr.rb', line 855

def inqscale
  inquiry_int { |pt| super(pt) }
end

.inqscalefactors3d ⇒ Object

Returns the scale factors for each axis.



1978
1979
1980
1981
1982
 
# File 'lib/gr.rb', line 1978

def inqscalefactors3d
  inquiry i[double double double] do |*opts|
    super(*opts)
  end
end

.inqspace ⇒ Object 



820
821
822
823
824
 
# File 'lib/gr.rb', line 820

def inqspace
  inquiry i[double double int int] do |*pts|
    super(*pts)
  end
end

.inqtext(x, y, string) ⇒ Object 



199
200
201
202
203
 
# File 'lib/gr.rb', line 199

def inqtext(x, y, string)
  inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
    super(x, y, string, tbx, tby)
  end
end

.inqtext3d(x, y, z, string, axis) ⇒ Object 



2004
2005
2006
2007
2008
 
# File 'lib/gr.rb', line 2004

def inqtext3d(x, y, z, string, axis)
  inquiry [{ double: 16 }, { double: 16 }] do |tbx, tby|
    super(x, y, z, string, axis, tbx, tby)
  end
end

.inqtextcolorind ⇒ Integer

Gets the current text color index. This function gets the color of text output primitives.

Returns:

  • (Integer) —

    color The text color index (COLOR < 1256)



548
549
550
 
# File 'lib/gr.rb', line 548

def inqtextcolorind
  inquiry_int { |pt| super(pt) }
end

.inqtextencoding ⇒ Object 



2014
2015
2016
2017
2018
 
# File 'lib/gr.rb', line 2014

def inqtextencoding
  inquiry_int do |encoding|
    super(encoding)
  end
end

.inqtextext(x, y, string) ⇒ Object

inqtextext



916
917
918
919
920
 
# File 'lib/gr.rb', line 916

def inqtextext(x, y, string)
  inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
    super(x, y, string, tbx, tby)
  end
end

.inqtransformationparameters ⇒ Object

Return the camera position, up vector and focus point.



1898
1899
1900
1901
1902
 
# File 'lib/gr.rb', line 1898

def inqtransformationparameters
  inquiry([:double] * 9) do |*pts|
    super(*pts)
  end
end

.inqviewport ⇒ Object

inqviewport



720
721
722
723
724
 
# File 'lib/gr.rb', line 720

def inqviewport
  inquiry i[double double double double] do |*pts|
    super(*pts)
  end
end

.inqwindow ⇒ Object

inqwindow



698
699
700
701
702
 
# File 'lib/gr.rb', line 698

def inqwindow
  inquiry i[double double double double] do |*pts|
    super(*pts)
  end
end

.inqwindow3d ⇒ Object

Return the three dimensional window.



1962
1963
1964
1965
1966
 
# File 'lib/gr.rb', line 1962

def inqwindow3d
  inquiry([:double] * 6) do |*pts|
    super(*pts)
  end
end

.interp2(x, y, z, xq, yq, method, extrapval) ⇒ Object

Interpolation in two dimensions using one of four different methods. The input points are located on a grid, described by x, y and z. The target grid ist described by xq and yq. Returns an array containing the resulting z-values.

Parameters:

  • x (Array, NArray) —

    Array containing the input grid’s x-values

  • y (Array, NArray) —

    Array containing the input grid’s y-values

  • z (Array, NArray) —

    Array containing the input grid’s z-values (number of values: nx * ny)

  • xq (Array, NArray) —

    Array containing the target grid’s x-values

  • yq (Array, NArray) —

    Array containing the target grid’s y-values

  • method (Integer) —

    Used method for interpolation The available methods for interpolation are the following:

    • 0 : INTERP2_NEAREST

      • Nearest neighbour interpolation

    • 1 : INTERP2_LINEAR

      • Linear interpolation

    • 2 : INTERP_2_SPLINE

      • Interpolation using natural cubic splines

    • 3 : INTERP2_CUBIC

      • Cubic interpolation

  • extrapval (Numeric) —

    The extrapolation value



1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
 
# File 'lib/gr.rb', line 1679

def interp2(x, y, z, xq, yq, method, extrapval) # flatten
  nx = x.length
  ny = y.length
  # nz = z.length
  nxq = xq.length
  nyq = yq.length
  inquiry(double: nxq * nyq) do |zq|
    super(nx, ny, x, y, z, nxq, nyq, xq, yq, zq, method, extrapval)
  end
end

.isosurface(v, kv = {}) ⇒ Object

(Plot) Draw an isosurface.



1349
1350
1351
1352
1353
1354
 
# File 'lib/gr/plot.rb', line 1349

def isosurface(v, kv = {})
  v = Numo::DFloat.cast(v) # Umm...
  create_plot(:isosurface, v, kv) do |plt|
    plt.args = [[nil, nil, v, nil, '']]
  end
end

.mathtex ⇒ Object

Generate a character string starting at the given location. Strings can be defined to create mathematical symbols and Greek letters using LaTeX syntax.

Parameters:

  • x (Numeric) —

    Position of the text string specified in world coordinates

  • y (Numeric) —

    Position of the text string specified in world coordinates

  • string (String) —

    The text string to be drawn



1525
1526
1527
 
# File 'lib/gr.rb', line 1525

def mathtex(*)
  super
end

.moveselection ⇒ Object 



1544
1545
1546
 
# File 'lib/gr.rb', line 1544

def moveselection(*)
  super
end

.ndctowc(x, y) ⇒ Object 



1296
1297
1298
1299
1300
1301
1302
 
# File 'lib/gr.rb', line 1296

def ndctowc(x, y)
  inquiry i[double double] do |px, py|
    px.write_double x
    py.write_double y
    super(px, py)
  end
end

.nonuniformcellarray(x, y, dimx, dimy, color) ⇒ Object

Display a two dimensional color index array with nonuniform cell sizes. The values for x and y are in world coordinates. x must contain dimx + 1 elements and y must contain dimy + 1 elements. The elements i and i+1 are respectively the edges of the i-th cell in X and Y direction.

Parameters:

  • x (Array, NArray) —

    X coordinates of the cell edges

  • y (Array, NArray) —

    Y coordinates of the cell edges

  • dimx (Integer) —

    X dimension of the color index array

  • dimy (Integer) —

    Y dimension of the color index array

  • color (Array, NArray) —

    Color index array

Raises:

  • (ArgumentError) 


242
243
244
245
246
 
# File 'lib/gr.rb', line 242

def nonuniformcellarray(x, y, dimx, dimy, color)
  raise ArgumentError unless x.length == dimx + 1 && y.length == dimy + 1

  super(x, y, dimx, dimy, 1, 1, dimx, dimy, int(color))
end

.opengks ⇒ Object 



91
92
93
 
# File 'lib/gr.rb', line 91

def opengks(*)
  super
end

.openws ⇒ Object

Open a graphical workstation.

Parameters:

  • workstation_id (Integer) —

    A workstation identifier.

  • connection (String) —

    A connection identifier.

  • workstation_type (Integer) —

    The desired workstation type.

    • 5 : Workstation Independent Segment Storage

    • 7, 8 : Computer Graphics Metafile (CGM binary, clear text)

    • 41 : Windows GDI

    • 51 : Mac Quickdraw

    • 61 - 64 : PostScript (b/w, color)

    • 101, 102 : Portable Document Format (plain, compressed)

    • 210 - 213 : X Windows

    • 214 : Sun Raster file (RF)

    • 215, 218 : Graphics Interchange Format (GIF87, GIF89)

    • 216 : Motif User Interface Language (UIL)

    • 320 : Windows Bitmap (BMP)

    • 321 : JPEG image file

    • 322 : Portable Network Graphics file (PNG)

    • 323 : Tagged Image File Format (TIFF)

    • 370 : Xfig vector graphics file

    • 371 : Gtk

    • 380 : wxWidgets

    • 381 : Qt4

    • 382 : Scaleable Vector Graphics (SVG)

    • 390 : Windows Metafile

    • 400 : Quartz

    • 410 : Socket driver

    • 415 : 0MQ driver

    • 420 : OpenGL

    • 430 : HTML5 Canvas



135
136
137
 
# File 'lib/gr.rb', line 135

def openws(*)
  super
end

.panzoom(x, y, zoom) ⇒ Object

panzoom



1752
1753
1754
1755
1756
 
# File 'lib/gr.rb', line 1752

def panzoom(x, y, zoom)
  inquiry i[double double double double] do |xmin, xmax, ymin, ymax|
    super(x, y, zoom, zoom, xmin, xmax, ymin, ymax)
  end
end

.path(x, y, codes) ⇒ Object

Draw paths using the given vertices and path codes. See gr-framework.org/python-gr.html#gr.path for more details.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • codes (String) —

    A list containing the path codes The following path codes are recognized:

    • M, m

      • moveto x, y

    • L, l

      • lineto x, y

    • Q, q

      • quadratic Bézier x1, x2 y1, y2

    • C, c

      • cubic Bézier x1, x2, x3 y1, y2, y3

    • A, a

      • arc rx, a1, reserved ry, a2, reserved

    • Z

      • close path -

    • s

      • stroke -

    • s

      • close path and stroke -

    • f

      • close path and fill -

    • F

      • close path, fill and stroke -



1839
1840
1841
1842
 
# File 'lib/gr.rb', line 1839

def path(x, y, codes)
  n = equal_length(x, y)
  super(n, x, y, codes)
end

.plot(*args) ⇒ Object

(Plot) Draw one or more line plots.



1185
1186
1187
 
# File 'lib/gr/plot.rb', line 1185

def plot(*args)
  create_plot(:line, *args)
end

.plot3(*args) ⇒ Object

(Plot) Draw one or more three-dimensional line plots.



1288
1289
1290
 
# File 'lib/gr/plot.rb', line 1288

def plot3(*args)
  create_plot(:plot3, *args)
end

.polar(*args) ⇒ Object

(Plot)



1278
1279
1280
 
# File 'lib/gr/plot.rb', line 1278

def polar(*args)
  create_plot(:polar, *args)
end

.polarcellarray(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, color) ⇒ Object

Display a two dimensional color index array mapped to a disk using polar coordinates. The two dimensional color index array is mapped to the resulting image by interpreting the X-axis of the array as the angle and the Y-axis as the raidus. The center point of the resulting disk is located at xorg, yorg and the radius of the disk is rmax.

Parameters:

  • xorg (Numeric) —

    X coordinate of the disk center in world coordinates

  • yorg (Numeric) —

    Y coordinate of the disk center in world coordinates

  • phimin (Numeric) —

    start angle of the disk sector in degrees

  • phimax (Numeric) —

    end angle of the disk sector in degrees

  • rmin (Numeric) —

    inner radius of the punctured disk in world coordinates

  • rmax (Numeric) —

    outer radius of the punctured disk in world coordinates

  • dimiphi (Integer) —

    Phi (X) dimension of the color index array

  • dimr (Integer) —

    iR (Y) dimension of the color index array

  • color (Array, NArray) —

    Color index array



264
265
266
 
# File 'lib/gr.rb', line 264

def polarcellarray(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, color)
  super(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, 1, 1, dimphi, dimr, int(color))
end

.polarheatmap(*args) ⇒ Object

(Plot) Draw a polarheatmap.



1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
 
# File 'lib/gr/plot.rb', line 1229

def polarheatmap(*args)
  d = args.shift
  # FIXME
  z = Numo::DFloat.cast(d)
  raise 'expected 2-D array' unless z.ndim == 2

  create_plot(:polarheatmap, z, *args) do |plt|
    width, height = z.shape
    plt.kvs[:xlim] ||= [0.5, width + 0.5]
    plt.kvs[:ylim] ||= [0.5, height + 0.5]
    plt.args = [[(1..width).to_a, (1..height).to_a, z, nil, '']]
  end
end

.polarhistogram(x, kv = {}) ⇒ Object

(Plot)



1205
1206
1207
1208
1209
1210
1211
1212
 
# File 'lib/gr/plot.rb', line 1205

def polarhistogram(x, kv = {})
  plt = GR::Plot.new(x, kv)
  plt.kvs[:kind] = :polarhist
  nbins = plt.kvs[:nbins] || 0
  x, y = hist(x, nbins)
  plt.args = [[x, y, nil, nil, '']]
  plt.plot_data
end

.polyline(x, y) ⇒ Object

Draw a polyline using the current line attributes, starting from the first data point and ending at the last data point.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates



173
174
175
176
 
# File 'lib/gr.rb', line 173

def polyline(x, y)
  n = equal_length(x, y)
  super(n, x, y)
end

.polyline3d(x, y, z) ⇒ Object

Draw a 3D curve using the current line attributes, starting from the first data point and ending at the last data point. The values for x, y and z are in world coordinates. The attributes that control the appearance of a polyline are linetype, linewidth and color index.

Parameters:

  • x (Array, NArray) —

    A list of length N containing the X coordinates

  • y (Array, NArray) —

    A list of length N containing the Y coordinates

  • z (Array, NArray) —

    A list of length N containing the Z coordinates



1021
1022
1023
1024
 
# File 'lib/gr.rb', line 1021

def polyline3d(x, y, z)
  n = equal_length(x, y, z)
  super(n, x, y, z)
end

.polymarker(x, y) ⇒ Object

Draw marker symbols centered at the given data points.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates



181
182
183
184
 
# File 'lib/gr.rb', line 181

def polymarker(x, y)
  n = equal_length(x, y)
  super(n, x, y)
end

.polymarker3d(x, y, z) ⇒ Object

Draw marker symbols centered at the given 3D data points. The values for x, y and z are in world coordinates. The attributes that control the appearance of a polymarker are marker type, marker size scale factor and color index.

Parameters:

  • x (Array, NArray) —

    A list of length N containing the X coordinates

  • y (Array, NArray) —

    A list of length N containing the Y coordinates

  • z (Array, NArray) —

    A list of length N containing the Z coordinates



1033
1034
1035
1036
 
# File 'lib/gr.rb', line 1033

def polymarker3d(x, y, z)
  n = equal_length(x, y, z)
  super(n, x, y, z)
end

.precision ⇒ Numeric

Returns:

  • (Numeric) 


1559
1560
1561
 
# File 'lib/gr.rb', line 1559

def precision(*)
  super
end

.quiver(x, y, u, v, color) ⇒ Object

Draw a quiver plot on a grid of nx*ny points. The values for x and y are in world coordinates.

Parameters:

  • nx (Integer) —

    The number of points along the x-axis of the grid

  • ny (Integer) —

    The number of points along the y-axis of the grid

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • u (Array, NArray) —

    A list containing the U component for each point on the grid

  • v (Array, NArray) —

    A list containing the V component for each point on the grid

  • color (Integer) —

    A bool to indicate whether or not the arrows should be colored using the current colormap



1652
1653
1654
1655
1656
1657
 
# File 'lib/gr.rb', line 1652

def quiver(x, y, u, v, color)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  super(nx, ny, x, y, u, v, (color ? 1 : 0))
end

.readimage(path) ⇒ Integer

Returns:

  • (Integer) 


1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
 
# File 'lib/gr.rb', line 1429

def readimage(path)
  # Feel free to make a pull request if you catch a mistake
  # or you have an idea to improve it.
  data = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T)
  w, h = inquiry [:int, :int] do |width, height|
    # data is a pointer of a pointer
    super(path, width, height, data.ref)
  end
  d = data.to_str(w * h * Fiddle::SIZEOF_INT).unpack('L*') # UInt32
  [w, h, d]
end

.redrawsegws ⇒ Object 



783
784
785
 
# File 'lib/gr.rb', line 783

def redrawsegws(*)
  super
end

.reducepoints(xd, yd, n) ⇒ Object

Reduces the number of points of the x and y array.



1614
1615
1616
1617
1618
1619
1620
 
# File 'lib/gr.rb', line 1614

def reducepoints(xd, yd, n)
  nd = equal_length(xd, yd)
  inquiry [{ double: n }, { double: n }] do |x, y|
    # Different from Julia. x, y are initialized zero.
    super(nd, xd, yd, n, x, y)
  end
end

.resizeselection ⇒ Object 



1548
1549
1550
 
# File 'lib/gr.rb', line 1548

def resizeselection(*)
  super
end

.restorestate ⇒ Object 



1576
1577
1578
 
# File 'lib/gr.rb', line 1576

def restorestate(*)
  super
end

.savefig(filename, kv = {}) ⇒ Object

(Plot) Save the current figure to a file.



1385
1386
1387
1388
1389
1390
1391
 
# File 'lib/gr/plot.rb', line 1385

def savefig(filename, kv = {})
  GR.beginprint(filename)
  plt = GR::Plot.last_plot
  plt.kvs.merge!(kv)
  plt.plot_data(false)
  GR.endprint
end

.savestate ⇒ Object 



1572
1573
1574
 
# File 'lib/gr.rb', line 1572

def savestate(*)
  super
end

.scatter(*args) ⇒ Object

(Plot) Draw one or more scatter plots.



1195
1196
1197
 
# File 'lib/gr/plot.rb', line 1195

def scatter(*args)
  create_plot(:scatter, *args)
end

.scatter3(*args) ⇒ Object

(Plot) Draw one or more three-dimensional scatter plots.



1293
1294
1295
 
# File 'lib/gr/plot.rb', line 1293

def scatter3(*args)
  create_plot(:scatter3, *args)
end

.selectcontext ⇒ Object 



1580
1581
1582
 
# File 'lib/gr.rb', line 1580

def selectcontext(*)
  super
end

.selntran ⇒ Object

selntran selects a predefined transformation from world coordinates to normalized device coordinates.

Parameters:

  • transform (Integer) —

    A normalization transformation number.

    • 0 : Selects the identity transformation in which both the window and viewport have the range of 0 to 1

    • >= 1 : Selects a normalization transformation as defined by setwindow and setviewport



731
732
733
 
# File 'lib/gr.rb', line 731

def selntran(*)
  super
end

.setarrowsize ⇒ Object

Set the arrow size to be used for subsequent arrow commands. setarrowsize defines the arrow size for subsequent arrow primitives. The default arrow size is 1.

Parameters:

  • size (Numeric) —

    The arrow size to be used



1412
1413
1414
 
# File 'lib/gr.rb', line 1412

def setarrowsize(*)
  super
end

.setarrowstyle ⇒ Object

Set the arrow style to be used for subsequent arrow commands. setarrowstyle defines the arrow style for subsequent arrow primitives.

Parameters:

  • style (Integer) —

    The arrow style to be used The default arrow style is 1.

    • 1 : simple, single-ended

    • 2 : simple, single-ended, acute head

    • 3 : hollow, single-ended

    • 4 : filled, single-ended

    • 5 : triangle, single-ended

    • 6 : filled triangle, single-ended

    • 7 : kite, single-ended

    • 8 : filled kite, single-ended

    • 9 : simple, double-ended

    • 10 : simple, double-ended, acute head

    • 11 : hollow, double-ended

    • 12 : filled, double-ended

    • 13 : triangle, double-ended

    • 14 : filled triangle, double-ended

    • 15 : kite, double-ended

    • 16 : filled kite, double-ended

    • 17 : double line, single-ended

    • 18 : double line, double-ended



1404
1405
1406
 
# File 'lib/gr.rb', line 1404

def setarrowstyle(*)
  super
end

.setbordercolorind ⇒ Object

Define the color of subsequent path output primitives.

Parameters:

  • color (Integer) —

    The border color index (COLOR < 1256)



1856
1857
1858
 
# File 'lib/gr.rb', line 1856

def setbordercolorind(*)
  super
end

.setborderwidth ⇒ Object

Define the border width of subsequent path output primitives.

Parameters:

  • width (Numeric) —

    The border width scale factor



1846
1847
1848
 
# File 'lib/gr.rb', line 1846

def setborderwidth(*)
  super
end

.setcharexpan ⇒ Object

Set the current character expansion factor (width to height ratio). setcharexpan defines the width of subsequent text output primitives. The expansion factor alters the width of the generated characters, but not their height. The default text expansion factor is 1, or one times the normal width-to-height ratio of the text.

Parameters:

  • factor (Numeric) —

    Text expansion factor applied to the nominal text width-to-height ratio



529
530
531
 
# File 'lib/gr.rb', line 529

def setcharexpan(*)
  super
end

.setcharheight ⇒ Object

Set the current character height. setcharheight defines the height of subsequent text output primitives. Text height is defined as a percentage of the default window. GR uses the default text height of 0.027 (2.7% of the height of the default window).

Parameters:

  • height (Numeric) —

    Text height value



557
558
559
 
# File 'lib/gr.rb', line 557

def setcharheight(*)
  super
end

.setcharspace ⇒ Object 



533
534
535
 
# File 'lib/gr.rb', line 533

def setcharspace(*)
  super
end

.setcharup ⇒ Object

Set the current character text angle up vector. setcharup defines the vertical rotation of subsequent text output primitives. The text up vector is initially set to (0, 1), horizontal to the baseline.

Parameters:

  • ux (Numeric) —

    Text up vector

  • uy (Numeric) —

    Text up vector



574
575
576
 
# File 'lib/gr.rb', line 574

def setcharup(*)
  super
end

.setclip ⇒ Object

Set the clipping indicator.

  • 0 : Clipping is off. Data outside of the window will be drawn.

  • 1 : Clipping is on. Data outside of the window will not be drawn.

setclip enables or disables clipping of the image drawn in the current window. Clipping is defined as the removal of those portions of the graph that lie outside of the defined viewport. If clipping is on, GR does not draw generated output primitives past the viewport boundaries. If clipping is off, primitives may exceed the viewport boundaries, and they will be drawn to the edge of the workstation window. By default, clipping is on.



745
746
747
 
# File 'lib/gr.rb', line 745

def setclip(*)
  super
end

.setcolormap ⇒ Object 



1167
1168
1169
 
# File 'lib/gr.rb', line 1167

def setcolormap(*)
  super
end

.setcolormapfromrgb(r, g, b, positions: nil) ⇒ Object

TODO: GR.jl python-gr different API



1177
1178
1179
1180
1181
1182
1183
1184
1185
 
# File 'lib/gr.rb', line 1177

def setcolormapfromrgb(r, g, b, positions: nil)
  n = equal_length(r, g, b)
  if positions.nil?
    positions = Fiddle::NULL
  elsif positions.length != n
    raise
  end
  super(n, r, g, b, positions)
end

.setcolorrep ⇒ Object

setcolorrep allows to redefine an existing color index representation by specifying an RGB color triplet.

Parameters:

  • index (Integer) —

    Color index in the range 0 to 1256

  • red (Numeric) —

    Red intensity in the range 0.0 to 1.0

  • green (Numeric) —

    Green intensity in the range 0.0 to 1.0

  • blue (Numeric) —

    Blue intensity in the range 0.0 to 1.0



676
677
678
 
# File 'lib/gr.rb', line 676

def setcolorrep(*)
  super
end

.setcoordxform(mat) ⇒ Object

Change the coordinate transformation according to the given matrix.

Parameters:

  • mat (Array, NArray) —

    2D transformation matrix



1491
1492
1493
1494
1495
 
# File 'lib/gr.rb', line 1491

def setcoordxform(mat)
  raise if mat.size != 6

  super(mat)
end

.setfillcolorind ⇒ Object

Sets the current fill area color index. setfillcolorind defines the color of subsequent fill area output primitives. GR uses the default foreground color (black=1) for the default fill area color index.

Parameters:

  • color (Integer) —

    The text color index (COLOR < 1256)



661
662
663
 
# File 'lib/gr.rb', line 661

def setfillcolorind(*)
  super
end

.setfillintstyle ⇒ Object

Set the fill area interior style to be used for fill areas. setfillintstyle defines the interior style for subsequent fill area output primitives. The default interior style is HOLLOW.

Parameters:

  • style (Integer) —

    The style of fill to be used

    • 0 : HOLLOW

      • No filling. Just draw the bounding polyline

    • 1 : SOLID

      • Fill the interior of the polygon using the fill color index

    • 2 : PATTERN

      • Fill the interior of the polygon using the style index as a pattern index

    • 3 : HATCH

      • Fill the interior of the polygon using the style index as a cross-hatched style



632
633
634
 
# File 'lib/gr.rb', line 632

def setfillintstyle(*)
  super
end

.setfillstyle ⇒ Object

Sets the fill style to be used for subsequent fill areas. setfillstyle specifies an index when PATTERN fill or HATCH fill is requested by the setfillintstyle function. If the interior style is set to PATTERN, the fill style index points to a device-independent pattern table. If interior style is set to HATCH the fill style index indicates different hatch styles. If HOLLOW or SOLID is specified for the interior style, the fill style index is unused.

Parameters:

  • index (Integer) —

    The fill style index to be used



648
649
650
 
# File 'lib/gr.rb', line 648

def setfillstyle(*)
  super
end

.setlinecolorind ⇒ Object

Define the color of subsequent polyline output primitives.

Parameters:

  • color (Integer) —

    The polyline color index (COLOR < 1256)



355
356
357
 
# File 'lib/gr.rb', line 355

def setlinecolorind(*)
  super
end

.setlinetype ⇒ Object

Specify the line style for polylines.

Parameters:

  • style (Integer) —

    The polyline line style

    • 1 : LINETYPE_SOLID

      • Solid line

    • 2 : LINETYPE_DASHED

      • Dashed line

    • 3 : LINETYPE_DOTTED

      • Dotted line

    • 4 : LINETYPE_DASHED_DOTTED

      • Dashed-dotted line

    • -1 : LINETYPE_DASH_2_DOT

      • Sequence of one dash followed by two dots

    • -2 : LINETYPE_DASH_3_DOT

      • Sequence of one dash followed by three dots

    • -3 : LINETYPE_LONG_DASH

      • Sequence of long dashes

    • -4 : LINETYPE_LONG_SHORT_DASH

      • Sequence of a long dash followed by a short dash

    • -5 : LINETYPE_SPACED_DASH

      • Sequence of dashes double spaced

    • -6 : LINETYPE_SPACED_DOT

      • Sequence of dots double spaced

    • -7 : LINETYPE_DOUBLE_DOT

      • Sequence of pairs of dots

    • -8 : LINETYPE_TRIPLE_DOT

      • Sequence of groups of three dots



331
332
333
 
# File 'lib/gr.rb', line 331

def setlinetype(*)
  super
end

.setlinewidth ⇒ Object

Define the line width of subsequent polyline output primitives. The line width is calculated as the nominal line width generated on the workstation multiplied by the line width scale factor. This value is mapped by the workstation to the nearest available line width. The default line width is 1.0, or 1 times the line width generated on the graphics device.

Parameters:

  • width (Numeric) —

    The polyline line width scale factor



345
346
347
 
# File 'lib/gr.rb', line 345

def setlinewidth(*)
  super
end

.setmarkercolorind ⇒ Object

Define the color of subsequent polymarker output primitives.

Parameters:

  • color (Integer) —

    The polymarker color index (COLOR < 1256)



464
465
466
 
# File 'lib/gr.rb', line 464

def setmarkercolorind(*)
  super
end

.setmarkersize ⇒ Object

Specify the marker size for polymarkers. The polymarker size is calculated as the nominal size generated on the graphics device multiplied by the marker size scale factor.

Parameters:

  • size (Numeric) —

    Scale factor applied to the nominal marker size



453
454
455
 
# File 'lib/gr.rb', line 453

def setmarkersize(*)
  super
end

.setmarkertype ⇒ Object

Specifiy the marker type for polymarkers. Polymarkers appear centered over their specified coordinates.

Parameters:

  • style (Integer) —

    The polymarker marker type

    • 1 : MARKERTYPE_DOT

      • Smallest displayable dot

    • 2 : MARKERTYPE_PLUS

      • Plus sign

    • 3 : MARKERTYPE_ASTERISK

      • Asterisk

    • 4 : MARKERTYPE_CIRCLE

      • Hollow circle

    • 5 : MARKERTYPE_DIAGONAL_CROSS

      • Diagonal cross

    • -1 : MARKERTYPE_SOLID_CIRCLE

      • Filled circle

    • -2 : MARKERTYPE_TRIANGLE_UP

      • Hollow triangle pointing upward

    • -3 : MARKERTYPE_SOLID_TRI_UP

      • Filled triangle pointing upward

    • -4 : MARKERTYPE_TRIANGLE_DOWN

      • Hollow triangle pointing downward

    • -5 : MARKERTYPE_SOLID_TRI_DOWN

      • Filled triangle pointing downward

    • -6 : MARKERTYPE_SQUARE

      • Hollow square

    • -7 : MARKERTYPE_SOLID_SQUARE

      • Filled square

    • -8 : MARKERTYPE_BOWTIE

      • Hollow bowtie

    • -9 : MARKERTYPE_SOLID_BOWTIE

      • Filled bowtie

    • -10 : MARKERTYPE_HGLASS

      • Hollow hourglass

    • -11 : MARKERTYPE_SOLID_HGLASS

      • Filled hourglass

    • -12 : MARKERTYPE_DIAMOND

      • Hollow diamond

    • -13 : MARKERTYPE_SOLID_DIAMOND

      • Filled Diamond

    • -14 : MARKERTYPE_STAR

      • Hollow star

    • -15 : MARKERTYPE_SOLID_STAR

      • Filled Star

    • -16 : MARKERTYPE_TRI_UP_DOWN

      • Hollow triangles pointing up and down overlaid

    • -17 : MARKERTYPE_SOLID_TRI_RIGHT

      • Filled triangle point right

    • -18 : MARKERTYPE_SOLID_TRI_LEFT

      • Filled triangle pointing left

    • -19 : MARKERTYPE_HOLLOW PLUS

      • Hollow plus sign

    • -20 : MARKERTYPE_SOLID PLUS

      • Solid plus sign

    • -21 : MARKERTYPE_PENTAGON

      • Pentagon

    • -22 : MARKERTYPE_HEXAGON

      • Hexagon

    • -23 : MARKERTYPE_HEPTAGON

      • Heptagon

    • -24 : MARKERTYPE_OCTAGON

      • Octagon

    • -25 : MARKERTYPE_STAR_4

      • 4-pointed star

    • -26 : MARKERTYPE_STAR_5

      • 5-pointed star (pentagram)

    • -27 : MARKERTYPE_STAR_6

      • 6-pointed star (hexagram)

    • -28 : MARKERTYPE_STAR_7

      • 7-pointed star (heptagram)

    • -29 : MARKERTYPE_STAR_8

      • 8-pointed star (octagram)

    • -30 : MARKERTYPE_VLINE

      • verical line

    • -31 : MARKERTYPE_HLINE

      • horizontal line

    • -32 : MARKERTYPE_OMARK

      • o-mark



441
442
443
 
# File 'lib/gr.rb', line 441

def setmarkertype(*)
  super
end

.setorthographicprojection ⇒ Object

Set parameters for orthographic transformation. Switches projection type to orthographic.

Parameters:

  • left (Numeric) —

    xmin of the volume in worldcoordinates

  • right (Numeric) —

    xmax of volume in worldcoordinates

  • bottom (Numeric) —

    ymin of volume in worldcoordinates

  • top (Numeric) —

    ymax of volume in worldcoordinates

  • near_plane (Numeric) —

    distance to near clipping plane

  • far_plane (Numeric) —

    distance to far clipping plane



1929
1930
1931
 
# File 'lib/gr.rb', line 1929

def setorthographicprojection(*)
  super
end

.setperspectiveprojection ⇒ Object

Set the far and near clipping plane for perspective projection and the vertical field ov view. Switches projection type to perspective.

Parameters:

  • near_plane (Numeric) —

    distance to near clipping plane

  • far_plane (Numeric) —

    distance to far clipping plane

  • fov (Numeric) —

    vertical field of view, input must be between 0 and 180 degrees



1910
1911
1912
 
# File 'lib/gr.rb', line 1910

def setperspectiveprojection(*)
  super
end

.setprojectiontype ⇒ Object

Set the projection type with this flag.

Parameters:

  • flag (Integer) —

    projection type The available options are:

    • 0 : GR_PROJECTION_DEFAULT

      • default

    • 1 : GR_PROJECTION_ORTHOGRAPHIC

      • orthographic

    • 2 : GR_PROJECTION_PERSPECTIVE

      • perspective



1873
1874
1875
 
# File 'lib/gr.rb', line 1873

def setprojectiontype(*)
  super
end

.setregenflags ⇒ Object 



1563
1564
1565
 
# File 'lib/gr.rb', line 1563

def setregenflags(*)
  super
end

.setresamplemethod ⇒ Object

Set the resample method used for gr.drawimage().

Parameters:

  • resample_method (Integer) —

    the new resample method. The available options are:

    • 0x00000000 : RESAMPLE_DEFAULT

      • default

    • 0x01010101 : RESAMPLE_NEAREST

      • nearest neighbour

    • 0x02020202 : RESAMPLE_LINEAR

      • linear

    • 0x03030303 : RESAMPLE_LANCZOS

      • Lanczos

    Alternatively, combinations of these methods can be selected for horizontal or vertical upsampling or downsampling:

    • 0x00000000 : UPSAMPLE_VERTICAL_DEFAULT

      • default for vertical upsampling

    • 0x00000000 : UPSAMPLE_HORIZONTAL_DEFAULT

      • default for horizontal upsampling

    • 0x00000000 : DOWNSAMPLE_VERTICAL_DEFAULT

      • default for vertical downsampling

    • 0x00000000 : DOWNSAMPLE_HORIZONTAL_DEFAULT

      • default for horizontal downsampling

    • 0x00000001 : UPSAMPLE_VERTICAL_NEAREST

      • nearest neighbor for vertical upsampling

    • 0x00000100 : UPSAMPLE_HORIZONTAL_NEAREST

      • nearest neighbor for horizontal upsampling

    • 0x00010000 : DOWNSAMPLE_VERTICAL_NEAREST

      • nearest neighbor for vertical downsampling

    • 0x01000000 : DOWNSAMPLE_HORIZONTAL_NEAREST

      • nearest neighbor for horizontal downsampling

    • 0x00000002 : UPSAMPLE_VERTICAL_LINEAR

      • linear for vertical upsampling

    • 0x00000200 : UPSAMPLE_HORIZONTAL_LINEAR

      • linear for horizontal upsampling

    • 0x00020000 : DOWNSAMPLE_VERTICAL_LINEAR

      • linear for vertical downsampling

    • 0x02000000 : DOWNSAMPLE_HORIZONTAL_LINEAR

      • linear for horizontal downsampling

    • 0x00000003 : UPSAMPLE_VERTICAL_LANCZOS

      • lanczos for vertical upsampling

    • 0x00000300 : UPSAMPLE_HORIZONTAL_LANCZOS

      • lanczos for horizontal upsampling

    • 0x00030000 : DOWNSAMPLE_VERTICAL_LANCZOS

      • lanczos for vertical downsampling

    • 0x03000000 : DOWNSAMPLE_HORIZONTAL_LANCZOS

      • lanczos for horizontal downsampling



1802
1803
1804
 
# File 'lib/gr.rb', line 1802

def setresamplemethod(*)
  super
end

.setscale ⇒ Integer

setscale sets the type of transformation to be used for subsequent GR output primitives. setscale defines the current transformation according to the given scale specification which may be or’ed together using any of the above options. GR uses these options for all subsequent output primitives until another value is provided. The scale options are used to transform points from an abstract logarithmic or semi-logarithmic coordinate system, which may be flipped along each axis, into the world coordinate system. Note: When applying a logarithmic transformation to a specific axis, the system assumes that the axes limits are greater than zero.

Parameters:

  • options (Integer) —

    Scale specification

    • 1 : OPTION_X_LOG

      • Logarithmic X-axis

    • 2 : OPTION_Y_LOG

      • Logarithmic Y-axis

    • 4 : OPTION_Z_LOG

      • Logarithmic Z-axis

    • 8 : OPTION_FLIP_X

      • Flip X-axis

    • 16 : OPTION_FLIP_Y

      • Flip Y-axis

    • 32 : OPTION_FLIP_Z

      • Flip Z-axis

Returns:

  • (Integer) 


850
851
852
 
# File 'lib/gr.rb', line 850

def setscale(*)
  super
end

.setscalefactors3d ⇒ Object

Set the scale factor for each axis. A one means no scale. All factor have to be != 0.

Parameters:

  • x_axis_scale (Numeric) —

    factor for scaling the x-axis

  • y_axis_scale (Numeric) —

    factor for scaling the y-axis

  • z_axis_scale (Numeric) —

    factor for scaling the z-axis



1973
1974
1975
 
# File 'lib/gr.rb', line 1973

def setscalefactors3d(*)
  super
end

.setsegtran ⇒ Object 



787
788
789
 
# File 'lib/gr.rb', line 787

def setsegtran(*)
  super
end

.setshadow ⇒ Object

setshadow allows drawing of shadows, realized by images painted underneath, and offset from, graphics objects such that the shadow mimics the effect of a light source cast on the graphics objects.

Parameters:

  • offsetx (Numeric) —

    An x-offset, which specifies how far in the horizontal direction the shadow is offset from the object

  • offsety (Numeric) —

    A y-offset, which specifies how far in the vertical direction the shadow is offset from the object

  • blur (Numeric) —

    A blur value, which specifies whether the object has a hard or a diffuse edge



1479
1480
1481
 
# File 'lib/gr.rb', line 1479

def setshadow(*)
  super
end

.setspace ⇒ Integer

Set the abstract Z-space used for mapping three-dimensional output primitives into the current world coordinate space. setspace establishes the limits of an abstract Z-axis and defines the angles for rotation and for the viewing angle (tilt) of a simulated three-dimensional graph, used for mapping corresponding output primitives into the current window. These settings are used for all subsequent three-dimensional output primitives until other values are specified. Angles of rotation and viewing angle must be specified between 0° and 90°.

Parameters:

  • zmin (Numeric) —

    Minimum value for the Z-axis.

  • zmax (Numeric) —

    Maximum value for the Z-axis.

  • rotation (Integer) —

    Angle for the rotation of the X axis, in degrees.

  • tilt (integer) —

    Viewing angle of the Z axis in degrees.

Returns:

  • (Integer) 


816
817
818
 
# File 'lib/gr.rb', line 816

def setspace(*)
  super
end

.setspace3d ⇒ Object

Set the camera for orthographic or perspective projection. The center of the 3d window is used as the focus point and the camera is positioned relative to it, using camera distance, rotation and tilt similar to gr_setspace. This function can be used if the user prefers spherical coordinates to setting the camera position directly, but has reduced functionality in comparison to GR.settransformationparameters, GR.setperspectiveprojection and GR.setorthographicprojection.

Parameters:

  • phi (Numeric) —

    azimuthal angle of the spherical coordinates

  • theta (Numeric) —

    polar angle of the spherical coordinates

  • fov (Numeric) —

    vertical field of view (0 or NaN for orthographic projection)

  • camera_distance (Numeric) —

    distance between the camera and the focus point (0 or NaN for the radius of the object’s smallest bounding sphere)



1996
1997
1998
 
# File 'lib/gr.rb', line 1996

def setspace3d(*)
  super
end

.settextalign ⇒ Object

Set the current horizontal and vertical alignment for text. settextalign specifies how the characters in a text primitive will be aligned in horizontal and vertical space. The default text alignment indicates horizontal left alignment and vertical baseline alignment.

Parameters:

  • horizontal (Integer) —

    Horizontal text alignment

    • 0 : TEXT_HALIGN_NORMAL

    • 1 : TEXT_HALIGN_LEFT

      • Left justify

    • 2 : TEXT_HALIGN_CENTER

      • Center justify

    • 3 : TEXT_HALIGN_RIGHT

      • Right justify

  • vertical (Integer) —

    Vertical text alignment

    • 0 : TEXT_VALIGN_NORMAL  

    • 1 : TEXT_VALIGN_TOP

      • Align with the top of the characters

    • 2 : TEXT_VALIGN_CAP

      • Aligned with the cap of the characters

    • 3 : TEXT_VALIGN_HALF

      • Aligned with the half line of the characters

    • 4 : TEXT_VALIGN_BASE

      • Aligned with the base line of the characters

    • 5 : TEXT_VALIGN_BOTTOM

      • Aligned with the bottom line of the characters



616
617
618
 
# File 'lib/gr.rb', line 616

def settextalign(*)
  super
end

.settextcolorind ⇒ Object

Sets the current text color index. settextcolorind defines the color of subsequent text output primitives. GR uses the default foreground color (black=1) for the default text color index.

Parameters:

  • color (Integer) —

    The text color index (COLOR < 1256)



541
542
543
 
# File 'lib/gr.rb', line 541

def settextcolorind(*)
  super
end

.settextencoding ⇒ Object 



2010
2011
2012
 
# File 'lib/gr.rb', line 2010

def settextencoding(*)
  super
end

.settextfontprec ⇒ Object

Specify the text font and precision for subsequent text output primitives. The appearance of a font depends on the text precision value specified. STRING, CHARACTER or STROKE precision allows for a greater or lesser realization of the text primitives, for efficiency. STRING is the default precision for GR and produces the highest quality output.

Parameters:

  • font (Integer) —

    Text font

    • 101 : FONT_TIMES_ROMAN

    • 102 : FONT_TIMES_ITALIC

    • 103 : FONT_TIMES_BOLD

    • 104 : FONT_TIMES_BOLDITALIC

    • 105 : FONT_HELVETICA

    • 106 : FONT_HELVETICA_OBLIQUE

    • 107 : FONT_HELVETICA_BOLD

    • 108 : FONT_HELVETICA_BOLDOBLIQUE

    • 109 : FONT_COURIER

    • 110 : FONT_COURIER_OBLIQUE

    • 111 : FONT_COURIER_BOLD

    • 112 : FONT_COURIER_BOLDOBLIQUE

    • 113 : FONT_SYMBOL

    • 114 : FONT_BOOKMAN_LIGHT

    • 115 : FONT_BOOKMAN_LIGHTITALIC

    • 116 : FONT_BOOKMAN_DEMI

    • 117 : FONT_BOOKMAN_DEMIITALIC

    • 118 : FONT_NEWCENTURYSCHLBK_ROMAN

    • 119 : FONT_NEWCENTURYSCHLBK_ITALIC

    • 120 : FONT_NEWCENTURYSCHLBK_BOLD

    • 121 : FONT_NEWCENTURYSCHLBK_BOLDITALIC

    • 122 : FONT_AVANTGARDE_BOOK

    • 123 : FONT_AVANTGARDE_BOOKOBLIQUE

    • 124 : FONT_AVANTGARDE_DEMI

    • 125 : FONT_AVANTGARDE_DEMIOBLIQUE

    • 126 : FONT_PALATINO_ROMAN

    • 127 : FONT_PALATINO_ITALIC

    • 128 : FONT_PALATINO_BOLD

    • 129 : FONT_PALATINO_BOLDITALIC

    • 130 : FONT_ZAPFCHANCERY_MEDIUMITALIC

    • 131 : FONT_ZAPFDINGBATS

    • 232 : FONT_COMPUTERMODERN

    • 233 : FONT_DEJAVUSANS

  • precision (Integer) —

    Text precision

    • 0 : TEXT_PRECISION_STRING

      • String precision (higher quality)

    • 1 : TEXT_PRECISION_CHAR

      • Character precision (medium quality)

    • 2 : TEXT_PRECISION_STROKE

      • Stroke precision (lower quality)

    • 3 : TEXT_PRECISION_OUTLINE

      • Outline precision (highest quality)



520
521
522
 
# File 'lib/gr.rb', line 520

def settextfontprec(*)
  super
end

.settextpath ⇒ Object

Define the current direction in which subsequent text will be drawn.

Parameters:

  • path (Integer) —

    Text path

    • 0 : TEXT_PATH_RIGHT

      • left-to-right

    • 1 : TEXT_PATH_LEFT

      • right-to-left

    • 2 : TEXT_PATH_UP

      • downside-up

    • 3 : TEXT_PATH_DOWN

      • upside-down



588
589
590
 
# File 'lib/gr.rb', line 588

def settextpath(*)
  super
end

.settransformationparameters ⇒ Object

Method to set the camera position, the upward facing direction and the focus point of the shown volume.

Parameters:

  • camera_pos_x (Numeric) —

    x component of the cameraposition in world coordinates

  • camera_pos_y (Numeric) —

    y component of the cameraposition in world coordinates

  • camera_pos_z (Numeric) —

    z component of the cameraposition in world coordinates

  • up_x (Numeric) —

    x component of the up vector

  • up_y (Numeric) —

    y component of the up vector

  • up_z (Numeric) —

    z component of the up vector

  • focus_point_x (Numeric) —

    x component of focus-point inside volume

  • focus_point_y (Numeric) —

    y component of focus-point inside volume

  • focus_point_z (Numeric) —

    z component of focus-point inside volume



1893
1894
1895
 
# File 'lib/gr.rb', line 1893

def settransformationparameters(*)
  super
end

.settransparency ⇒ Object

Set the value of the alpha component associated with GR colors.

Parameters:

  • alpha (Numeric) —

    An alpha value (0.0 - 1.0)



1485
1486
1487
 
# File 'lib/gr.rb', line 1485

def settransparency(*)
  super
end

.setviewport ⇒ Object

setviewport establishes a rectangular subspace of normalized device coordinates. setviewport defines the rectangular portion of the Normalized Device Coordinate (NDC) space to be associated with the specified normalization transformation. The NDC viewport and World Coordinate (WC) window define the normalization transformation through which all output primitives pass. The WC window is mapped onto the rectangular NDC viewport which is, in turn, mapped onto the display surface of the open and active workstation, in device coordinates.

Parameters:

  • xmin (Numeric) —

    The left horizontal coordinate of the viewport.

  • xmax (Numeric) —

    The right horizontal coordinate of the viewport (0 <= xmin < xmax <= 1).

  • ymin (Numeric) —

    The bottom vertical coordinate of the viewport.

  • ymax (Numeric) —

    The top vertical coordinate of the viewport (0 <= ymin < ymax <= 1).



715
716
717
 
# File 'lib/gr.rb', line 715

def setviewport(*)
  super
end

.setwindow ⇒ Object

setwindow establishes a window, or rectangular subspace, of world coordinates to be plotted. If you desire log scaling or mirror-imaging of axes, use the SETSCALE function. setwindow defines the rectangular portion of the World Coordinate space (WC) to be associated with the specified normalization transformation. The WC window and the Normalized Device Coordinates (NDC) viewport define the normalization transformation through which all output primitives are mapped. The WC window is mapped onto the rectangular NDC viewport which is, in turn, mapped onto the display surface of the open and active workstation, in device coordinates. By default, GR uses the range [0,1] x [0,1], in world coordinates, as the normalization transformation window.

Parameters:

  • xmin (Numeric) —

    The left horizontal coordinate of the window (xmin < xmax).

  • xmax (Numeric) —

    The right horizontal coordinate of the window.

  • ymin (Numeric) —

    The bottom vertical coordinate of the window (ymin < ymax).

  • ymax (Numeric) —

    The top vertical coordinate of the window.



693
694
695
 
# File 'lib/gr.rb', line 693

def setwindow(*)
  super
end

.setwindow3d ⇒ Object

Set the three dimensional window. Only used for perspective and orthographic projection.

Parameters:

  • xmin (Numeric) —

    min x-value

  • xmax (Numeric) —

    max x-value

  • ymin (Numeric) —

    min y-value

  • ymax (Numeric) —

    max y-value

  • zmin (Numeric) —

    min z-value

  • zmax (Numeric) —

    max z-value



1957
1958
1959
 
# File 'lib/gr.rb', line 1957

def setwindow3d(*)
  super
end

.setwsviewport ⇒ Object

Define the size of the workstation graphics window in meters. setwsviewport places a workstation window on the display of the specified size in meters. This command allows the workstation window to be accurately sized for a display or hardcopy device, and is often useful for sizing graphs for desktop publishing applications.

Parameters:

  • xmin (Numeric) —

    The left horizontal coordinate of the workstation viewport.

  • xmax (Numeric) —

    The right horizontal coordinate of the workstation viewport.

  • ymin (Numeric) —

    The bottom vertical coordinate of the workstation viewport.

  • ymax (Numeric) —

    The top vertical coordinate of the workstation viewport.



771
772
773
 
# File 'lib/gr.rb', line 771

def setwsviewport(*)
  super
end

.setwswindow ⇒ Object

Set the area of the NDC viewport that is to be drawn in the workstation window. setwswindow defines the rectangular area of the Normalized Device Coordinate space to be output to the device. By default, the workstation transformation will map the range [0,1] x [0,1] in NDC onto the largest square on the workstation’s display surface. The aspect ratio of the workstation window is maintained at 1 to 1.

Parameters:

  • xmin (Numeric) —

    The left horizontal coordinate of the workstation window.

  • xmax (Numeric) —

    The right horizontal coordinate of the workstation window (0 <= xmin < xmax <= 1).

  • ymin (Numeric) —

    The bottom vertical coordinate of the workstation window.

  • ymax (Numeric) —

    The top vertical coordinate of the workstation window (0 <= ymin < ymax <= 1).



758
759
760
 
# File 'lib/gr.rb', line 758

def setwswindow(*)
  super
end

.shade(*args) ⇒ Object

(Plot)



1299
1300
1301
 
# File 'lib/gr/plot.rb', line 1299

def shade(*)
  super
end

.shadelines(x, y, dims: [1200, 1200], xform: 1) ⇒ Object

Display a line set as an aggregated and rasterized image. The values for x and y are in world coordinates. NaN values can be used to separate the point set into line segments.

Parameters:

  • x (Array, NArray) —

    A pointer to the X coordinates

  • y (Array, NArray) —

    A pointer to the Y coordinates

  • dims (Array, NArray) (defaults to: [1200, 1200]) —

    The size of the grid used for rasterization

  • xform (Integer) (defaults to: 1) —

    The transformation type used for color mapping The available transformation types are:

    • 0 : XFORM_BOOLEAN

      • boolean

    • 1 : XFORM_LINEAR

      • linear

    • 2 : XFORM_LOG

      • logarithmic

    • 3 : XFORM_LOGLOG

      • double logarithmic

    • 4 : XFORM_CUBIC

      • cubic

    • 5 : XFORM_EQUALIZED

      • histogram equalized



1745
1746
1747
1748
1749
 
# File 'lib/gr.rb', line 1745

def shadelines(x, y, dims: [1200, 1200], xform: 1)
  n = x.length
  w, h = dims
  super(n, x, y, xform, w, h)
end

.shadepoints(x, y, dims: [1200, 1200], xform: 1) ⇒ Object

Display a point set as a aggregated and rasterized image. The values for x and y are in world coordinates.

Parameters:

  • x (Array, NArray) —

    A pointer to the X coordinates

  • y (Array, NArray) —

    A pointer to the Y coordinates

  • dims (Array, NArray) (defaults to: [1200, 1200]) —

    The size of the grid used for rasterization

  • xform (Integer) (defaults to: 1) —

    The transformation type used for color mapping The available transformation types are:

    • 0 : XFORM_BOOLEAN

      • boolean

    • 1 : XFORM_LINEAR

      • linear

    • 2 : XFORM_LOG

      • logarithmic

    • 3 : XFORM_LOGLOG

      • double logarithmic

    • 4 : XFORM_CUBIC

      • cubic

    • 5 : XFORM_EQUALIZED

      • histogram equalized



1719
1720
1721
1722
1723
 
# File 'lib/gr.rb', line 1719

def shadepoints(x, y, dims: [1200, 1200], xform: 1)
  n = x.length
  w, h = dims
  super(n, x, y, xform, w, h)
end

.spline(x, y, m, method) ⇒ Object

Generate a cubic spline-fit, starting from the first data point and ending at the last data point. The values for x and y are in world coordinates. The attributes that control the appearance of a spline-fit are linetype, linewidth and color index.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • m (Integer) —

    The number of points in the polygon to be drawn (m > len(x))

  • method (Integer) —

    The smoothing method

    • If method is > 0, then a generalized cross-validated smoothing spline is calculated.

    • If method is 0, then an interpolating natural cubic spline is calculated.

    • If method is < -1, then a cubic B-spline is calculated.



293
294
295
296
 
# File 'lib/gr.rb', line 293

def spline(x, y, m, method)
  n = equal_length(x, y)
  super(n, x, y, m, method)
end

.stem(*args) ⇒ Object

(Plot) Draw a stem plot.



1200
1201
1202
 
# File 'lib/gr/plot.rb', line 1200

def stem(*args)
  create_plot(:stem, *args)
end

.step(*args) ⇒ Object

(Plot) Draw one or more step or staircase plots.



1190
1191
1192
 
# File 'lib/gr/plot.rb', line 1190

def step(*args)
  create_plot(:step, *args)
end

.subplot(nr, nc, p, kv = {}) ⇒ Object

Set current subplot index.



1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
 
# File 'lib/gr/plot.rb', line 1362

def subplot(nr, nc, p, kv = {})
  xmin = 1
  xmax = 0
  ymin = 1
  ymax = 0
  p = [p] if p.is_a? Integer
  p.each do |i|
    r = (nr - (i - 1) / nc).to_f
    c = ((i - 1) % nc + 1).to_f
    xmin = [xmin, (c - 1) / nc].min
    xmax = [xmax, c / nc].max
    ymin = [ymin, (r - 1) / nr].min
    ymax = [ymax, r / nr].max
  end
  {
    subplot: [xmin, xmax, ymin, ymax],
    # The policy of clearing when p[0]==1 is controversial
    clear: p[0] == 1,
    update: p[-1] == nr * nc
  }.merge kv
end

.surface(*args) ⇒ Object

Draw a three-dimensional surface plot for the given data points. x and y define a grid. z is a singly dimensioned array containing at least nx * ny data points. Z describes the surface height at each point on the grid. Data is ordered as shown in the table:

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • z (Array, NArray) —

    A list of length ‘len(x)` * `len(y)` or an appropriately dimensioned array containing the Z coordinates

  • option (Integer) —

    Surface display option

    • 0 LINES

      • Use X Y polylines to denote the surface

    • 1 MESH

      • Use a wire grid to denote the surface

    • 2 FILLED_MESH

      • Applies an opaque grid to the surface

    • 3 Z_SHADED_MESH

      • Applies Z-value shading to the surface

    • 4 COLORED_MESH

      • Applies a colored grid to the surface

    • 5 CELL_ARRAY

      • Applies a grid of individually-colored cells to the surface

    • 6 SHADED_MESH

      • Applies light source shading to the 3-D surface



1105
1106
1107
1108
1109
1110
 
# File 'lib/gr.rb', line 1105

def surface(x, y, z, option)
  # TODO: check: Arrays have incorrect length or dimension.
  nx = x.length
  ny = y.length
  super(nx, ny, x, y, z, option)
end

.text ⇒ Object

Draw a text at position x, y using the current text attributes. The values for x and y are in normalized device coordinates. The attributes that control the appearance of text are text font and precision, character expansion factor, character spacing, text color index, character height, character up vector, text path and text alignment.

Parameters:

  • x (Numeric) —

    The X coordinate of starting position of the text string

  • y (Numeric) —

    The Y coordinate of starting position of the text string

  • string (String) —

    The text to be drawn



195
196
197
 
# File 'lib/gr.rb', line 195

def text(*)
  super
end

.text3d ⇒ Object 



2000
2001
2002
 
# File 'lib/gr.rb', line 2000

def text3d(*)
  super
end

.textext ⇒ Integer

Draw a text at position x, y using the current text attributes. Strings can be defined to create basic mathematical expressions and Greek letters. The values for X and Y are in normalized device coordinates. The attributes that control the appearance of text are text font and precision, character expansion factor, character spacing, text color index, character height, character up vector, text path and text alignment.

The character string is interpreted to be a simple mathematical formula. The following notations apply:

Subscripts and superscripts: These are indicated by carets (‘^’) and underscores (‘_’). If the sub/superscript contains more than one character, it must be enclosed in curly braces (‘{}’).

Fractions are typeset with A ‘/’ B, where A stands for the numerator and B for the denominator.

To include a Greek letter you must specify the corresponding keyword after a backslash (‘') character. The text translator produces uppercase or lowercase Greek letters depending on the case of the keyword.

*

Note: \v is a replacement for \nu which would conflict with \n (newline) For more sophisticated mathematical formulas, you should use the gr.mathtex function.

Parameters:

  • x (Numeric) —

    The X coordinate of starting position of the text string

  • y (Numeric) —

    The Y coordinate of starting position of the text string

  • string (String) —

    The text to be drawn

Returns:

  • (Integer) 


911
912
913
 
# File 'lib/gr.rb', line 911

def textext(*)
  super
end

.tick ⇒ Numeric

Returns:

  • (Numeric) 


1209
1210
1211
 
# File 'lib/gr.rb', line 1209

def tick(*)
  super
end

.titles3d ⇒ Object

Display axis titles just outside of their respective axes.

Parameters:

  • x_title (String) —

    The text to be displayed on the X axis

  • x_title (String) —

    The text to be displayed on the Y axis

  • x_title (String) —

    The text to be displayed on the Z axis



1077
1078
1079
 
# File 'lib/gr.rb', line 1077

def titles3d(*)
  super
end

.tricont(*args) ⇒ Object

(Plot) Draw a triangular contour plot.



1262
1263
1264
 
# File 'lib/gr/plot.rb', line 1262

def tricont(*args)
  create_plot(:tricont, *format_xyzc(*args))
end

.tricontour(x, y, z, levels) ⇒ Object

Draw a contour plot for the given triangle mesh.



1155
1156
1157
1158
1159
 
# File 'lib/gr.rb', line 1155

def tricontour(x, y, z, levels)
  npoints = x.length # equal_length ?
  nlevels = levels.length
  super(npoints, x, y, z, nlevels, levels)
end

.trisurf(*args) ⇒ Object

(Plot) Draw a triangular surface plot.



1283
1284
1285
 
# File 'lib/gr/plot.rb', line 1283

def trisurf(*args)
  create_plot(:trisurf, *format_xyzc(*args))
end

.trisurface(x, y, z) ⇒ Object

Draw a triangular surface plot for the given data points.

Parameters:

  • x (Array, NArray) —

    A list containing the X coordinates

  • y (Array, NArray) —

    A list containing the Y coordinates

  • z (Array, NArray) —

    A list containing the Z coordinates



1626
1627
1628
1629
 
# File 'lib/gr.rb', line 1626

def trisurface(x, y, z)
  n = [x, y, z].map(&:length).min
  super(n, x, y, z)
end

.updategks ⇒ Object 



799
800
801
 
# File 'lib/gr.rb', line 799

def updategks(*)
  super
end

.updatews ⇒ Object 



165
166
167
 
# File 'lib/gr.rb', line 165

def updatews(*)
  super
end

.uselinespec ⇒ Integer

Returns:

  • (Integer) 


1589
1590
1591
 
# File 'lib/gr.rb', line 1589

def uselinespec(*)
  super
end

.validaterange ⇒ Integer

Returns:

  • (Integer) 


1214
1215
1216
 
# File 'lib/gr.rb', line 1214

def validaterange(*)
  super
end

.verrorbars(x, y, e1, e2) ⇒ Object

Draw a standard vertical error bar graph.

Parameters:

  • x (Array, NArray) —

    A list of length N containing the X coordinates

  • y (Array, NArray) —

    A list of length N containing the Y coordinates

  • e1 (Array, NArray) —

    The absolute values of the lower error bar data

  • e2 (Array, NArray) —

    The absolute values of the lower error bar data



998
999
1000
1001
 
# File 'lib/gr.rb', line 998

def verrorbars(x, y, e1, e2)
  n = equal_length(x, y, e1, e2)
  super(n, x, y, e1, e2)
end

.version ⇒ String

Returns the combined version strings of the GR runtime.

Returns:

  • (String) 


1692
1693
1694
 
# File 'lib/gr.rb', line 1692

def version
  super.to_s
end

.volume(v, kv = {}) ⇒ Object

(Plot)



1304
1305
1306
1307
1308
 
# File 'lib/gr/plot.rb', line 1304

def volume(v, kv = {})
  create_plot(:volume, v, kv) do |plt|
    plt.args = [[nil, nil, v, nil, '']]
  end
end

.wc3towc(x, y, z) ⇒ Object 



1312
1313
1314
1315
1316
1317
1318
1319
 
# File 'lib/gr.rb', line 1312

def wc3towc(x, y, z)
  inquiry i[double double double] do |px, py, pz|
    px.write_double x
    py.write_double y
    pz.write_double z
    super(px, py, pz)
  end
end

.wctondc(x, y) ⇒ Object 



1304
1305
1306
1307
1308
1309
1310
 
# File 'lib/gr.rb', line 1304

def wctondc(x, y)
  inquiry i[double double] do |px, py|
    px.write_double x
    py.write_double y
    super(px, py)
  end
end

.wireframe(*args) ⇒ Object

(Plot) Draw a three-dimensional wireframe plot.



1267
1268
1269
 
# File 'lib/gr/plot.rb', line 1267

def wireframe(*args)
  create_plot(:wireframe, *format_xyzc(*args))
end