Module: GR

Extended by:
GRCommons::GRCommonUtils, GRCommons::JupyterSupport
Defined in:
lib/gr.rb,
lib/gr/ffi.rb,
lib/gr/grbase.rb,
lib/gr/version.rb,
lib/gr_commons/gr_logger.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, NotFoundError

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
AXES_SIMPLE_AXES = 
1
AXES_TWIN_AXES = 
2
AXES_WITH_GRID = 
4
REGION_RECTANGLE = 
0
REGION_ELLIPSE = 
1
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_X_LOG2 = 
64
OPTION_Y_LOG2 = 
128
OPTION_Z_LOG2 = 
256
OPTION_X_LN = 
512
OPTION_Y_LN = 
1024
OPTION_Z_LN = 
2048
SPEC_LINE = 
1
SPEC_MARKER = 
2
SPEC_COLOR = 
4
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
OPTION_3D_MESH = 
7
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
GDP_DRAW_PATH = 
1
GDP_DRAW_LINES = 
2
GDP_DRAW_MARKERS = 
3
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
VOLUME_WITHOUT_BORDER = 
0
VOLUME_WITH_BORDER = 
1
VOLUME_EMISSION = 
0
VOLUME_ABSORPTION = 
1
VOLUME_MIP = 
2
TEXT_USE_WC = 
(1 << 0)
TEXT_ENABLE_INLINE_MATH = 
(1 << 1)
VERSION = 
GRCommons::VERSION

Constants included from GRCommons::GRCommonUtils

GRCommons::GRCommonUtils::SUPPORTED_TYPES

Class Attribute Summary collapse

Class Method Summary collapse

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.



54
55
56
 
# File 'lib/gr.rb', line 54

def ffi_lib
  @ffi_lib
end

Class Method Details

.activatews ⇒ Object

Activate the specified workstation.




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

.adjustlimits(amin, amax) ⇒ Integer 



1557
1558
1559
1560
1561
1562
1563
 
# File 'lib/gr.rb', line 1557

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 



1565
1566
1567
1568
1569
1570
1571
 
# File 'lib/gr.rb', line 1565

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.

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 gr_setlinetype and gr_setlinewidth functions. Axes are drawn according to the linear or logarithmic transformation established by the gr_setscale function.



1117
 
# File 'lib/gr.rb', line 1117

alias axes2d axes

.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.




# File 'lib/gr.rb', line 1324

.axeslbl ⇒ Object

Note:

This method uses GRCommons::Fiddley::Function as a callback function. Please read the source code If you have to use it. There are some examples of the use of this function in the Plot class..

Create axes in the current workspace and supply a custom function for changing the behaviour of the tick labels.

Similar to gr_axes() but allows more fine-grained control over tick labels and text positioning by supplying callback functions. Within the callback function you can use normal GR text primitives for performing any manipulations on the label text. See gr_axes() for more details on drawing axes.

  • fpx/fpy

    • param x [Numeric] NDC of the label in X direction.

    • param y [Numeric] NDC of the label in Y direction.

    • param svalue [String] Internal string representation of the text drawn by GR at (x,y).

    • param value [Numeric] Floating point representation of the label drawn at (x,y).




# File 'lib/gr.rb', line 1165

.axis(option, min: Float::NAN, max: Float::NAN, tick: Float::NAN, org: Float::NAN, position: Float::NAN, major_count: 1, tick_size: Float::NAN, label_position: Float::NAN, draw_axis_line: 1, label_orientation: 0) ⇒ Object 



1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
 
# File 'lib/gr.rb', line 1119

def axis(option, min: Float::NAN, max: Float::NAN, tick: Float::NAN, org: Float::NAN, position: Float::NAN, major_count: 1,
         tick_size: Float::NAN, label_position: Float::NAN, draw_axis_line: 1, label_orientation: 0)
  ax = FFI::Axis.malloc
  ax[:min] = min
  ax[:max] = max
  ax[:tick] = tick
  ax[:org] = org
  ax[:position] = position
  ax[:major_count] = major_count
  ax[:tick_size] = tick_size
  ax[:label_position] = label_position
  ax[:draw_axis_line] = draw_axis_line
  ax[:label_orientation] = label_orientation
  ax[:ticks] = 0
  ax[:num_ticks] = 0
  ax[:tick_labels] = 0
  ax[:num_tick_labels] = 0
  super(option, ax)
  ax
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.




# File 'lib/gr.rb', line 1854

.beginprint(file_path) ⇒ Object

Note:

Ruby feature - you can use block to call endprint automatically.

Open and activate a print device.

beginprint opens an additional graphics output device. The device type is obtained from the given file extension



1594
1595
1596
1597
1598
1599
1600
 
# File 'lib/gr.rb', line 1594

def beginprint(file_path)
  super(file_path)
  return unless block_given?

  yield
  endprint
end

.beginprintext ⇒ Object

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




# File 'lib/gr.rb', line 1602

.beginselection ⇒ Object 




# File 'lib/gr.rb', line 1889

.camerainteraction ⇒ Object

Rotate the current scene according to a virtual arcball.

This function requires values between 0 (left side or bottom of the drawing area) and 1 (right side or top of the drawing area).




# File 'lib/gr.rb', line 2311

.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.



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

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

Clear the specified workstation.




# File 'lib/gr.rb', line 171

.closegks ⇒ Object 




# File 'lib/gr.rb', line 103

.closeseg ⇒ Object 




# File 'lib/gr.rb', line 957

.closews ⇒ Object

Close the specified workstation.




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

.colorbar ⇒ Object 



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

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

.configurews ⇒ Object

Configure the specified workstation.




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

.contour(x, y, h, z, major_h) ⇒ Object

Note:

contour is overwritten by ‘require gr/plot`. The original method is moved to the underscored name. The yard document will show the method name after evacuation.

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

Raises:

  • (ArgumentError) 


1425
1426
1427
1428
1429
1430
1431
1432
 
# File 'lib/gr.rb', line 1425

def contour(x, y, h, z, major_h)
  nx = x.length
  ny = y.length
  nh = h.length
  raise ArgumentError, "z must have length nx * ny (expected #{nx * ny}, got #{z.length})" if z.length != nx * ny

  super(nx, ny, nh, x, y, h, z, major_h)
end

.contourf(x, y, h, z, major_h) ⇒ Object

Note:

contourf is overwritten by ‘require gr/plot`. The original method is moved to the underscored name. The yard document will show the method name after evacuation.

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

Raises:

  • (ArgumentError) 


1451
1452
1453
1454
1455
1456
1457
1458
 
# File 'lib/gr.rb', line 1451

def contourf(x, y, h, z, major_h)
  nx = x.length
  ny = y.length
  nh = h.length
  raise ArgumentError, "z must have length nx * ny (expected #{nx * ny}, got #{z.length})" if z.length != nx * ny

  super(nx, ny, nh, x, y, h, z, major_h)
end

.copysegws ⇒ Object 




# File 'lib/gr.rb', line 951

.cpubasedvolume ⇒ Object

FIXME! (#61)



2464
2465
2466
2467
2468
 
# File 'lib/gr.rb', line 2464

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

.createseg ⇒ Object 




# File 'lib/gr.rb', line 949

.deactivatews ⇒ Object

Deactivate the specified workstation.




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

.delaunay(x, y) ⇒ Integer 



1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
 
# File 'lib/gr.rb', line 1924

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, Fiddle::RUBY_FREE)
  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 




# File 'lib/gr.rb', line 1919

.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.




# File 'lib/gr.rb', line 1687

.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.




# File 'lib/gr.rb', line 1771

.drawaxes(x_axis, y_axis, option = 1) ⇒ Object 



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

def drawaxes(x_axis, y_axis, option = 1)
  super(x_axis, y_axis, option)
end

.drawaxis(option, min: Float::NAN, max: Float::NAN, tick: Float::NAN, org: Float::NAN, position: Float::NAN, major_count: 1, tick_size: Float::NAN, label_position: Float::NAN, draw_axis_line: 1, label_orientation: 0) ⇒ Object 



1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
 
# File 'lib/gr.rb', line 1140

def drawaxis(option, min: Float::NAN, max: Float::NAN, tick: Float::NAN, org: Float::NAN, position: Float::NAN,
             major_count: 1, tick_size: Float::NAN, label_position: Float::NAN, draw_axis_line: 1, label_orientation: 0)
  ax = FFI::Axis.malloc
  ax[:min] = min
  ax[:max] = max
  ax[:tick] = tick
  ax[:org] = org
  ax[:position] = position
  ax[:major_count] = major_count
  ax[:tick_size] = tick_size
  ax[:label_position] = label_position
  ax[:draw_axis_line] = draw_axis_line
  ax[:label_orientation] = label_orientation
  ax[:ticks] = 0
  ax[:num_ticks] = 0
  ax[:tick_labels] = 0
  ax[:num_tick_labels] = 0
  super(option, ax)
  ax
end

.drawgraphics ⇒ Integer 




# File 'lib/gr.rb', line 1870

.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.



1816
1817
1818
 
# File 'lib/gr.rb', line 1816

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.



1731
1732
1733
1734
 
# File 'lib/gr.rb', line 1731

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.




# File 'lib/gr.rb', line 1669

.emergencyclosegks ⇒ Object 




# File 'lib/gr.rb', line 959

.endgraphics ⇒ Object 




# File 'lib/gr.rb', line 1863

.endprint ⇒ Object 



1644
1645
1646
1647
1648
1649
1650
 
# File 'lib/gr.rb', line 1644

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

.endselection ⇒ Object 




# File 'lib/gr.rb', line 1891

.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.




# File 'lib/gr.rb', line 1702

.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.



311
312
313
314
 
# File 'lib/gr.rb', line 311

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.




# File 'lib/gr.rb', line 1678

.findboundary ⇒ Object

Note:

This method uses GRCommons::Fiddley::Function as a callback function. Please read the source code If you have to use it. This method is not sure if it works properly.




# File 'lib/gr.rb', line 2092

.ftoa(value, format_ref) ⇒ Object 



2509
2510
2511
2512
2513
 
# File 'lib/gr.rb', line 2509

def ftoa(value, format_ref)
  string = Fiddle::Pointer.malloc(256)
  super(string, value, format_ref)
  string.to_s
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.



431
432
433
434
435
 
# File 'lib/gr.rb', line 431

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

.getformat(origin, min, max, tick_width, major) ⇒ Object 



2503
2504
2505
2506
2507
 
# File 'lib/gr.rb', line 2503

def getformat(origin, min, max, tick_width, major)
  ref = FFI::FormatReference.malloc
  super(ref, origin, min, max, tick_width, major)
  ref
end

.getgraphics ⇒ String 



1866
1867
1868
 
# File 'lib/gr.rb', line 1866

def getgraphics(*)
  super.to_s
end

.gr_setresizebehaviour ⇒ Object 



814
815
816
 
# File 'lib/gr.rb', line 814

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

.gradient(x, y, z) ⇒ Object

Deprecated.

Raises:

  • (ArgumentError) 


1970
1971
1972
1973
1974
1975
1976
1977
1978
 
# File 'lib/gr.rb', line 1970

def gradient(x, y, z)
  nx = x.length
  ny = y.length
  raise ArgumentError, "z must have length nx * ny (expected #{nx * ny}, got #{z.length})" if z.length != nx * ny

  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.




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

.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.




# File 'lib/gr.rb', line 1238

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

Interpolate data from arbitrary points at points on a rectangular grid.



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

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

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

Draw a standard horizontal error bar graph.



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

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

.hexbin(x, y, nbins) ⇒ Integer

Note:

hexbin is overwritten by ‘require gr/plot`. The original method is moved to the underscored name. The yard document will show the method name after evacuation.



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

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

.hsvtorgb(h, s, v) ⇒ Integer 



1545
1546
1547
1548
1549
 
# File 'lib/gr.rb', line 1545

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 




# File 'lib/gr.rb', line 1820

.initgr ⇒ Object 




# File 'lib/gr.rb', line 99

.inqbbox ⇒ Object 



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

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

.inqbordercolorind ⇒ Object

Define the color of subsequent path output primitives.



2225
2226
2227
 
# File 'lib/gr.rb', line 2225

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

.inqborderwidth ⇒ Object

Define the border width of subsequent path output primitives.



2215
2216
2217
 
# File 'lib/gr.rb', line 2215

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

.inqcharheight ⇒ Numeric

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).



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

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

.inqclipregion ⇒ Object 



2491
2492
2493
 
# File 'lib/gr.rb', line 2491

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

.inqclipsector ⇒ Object 



2497
2498
2499
2500
2501
 
# File 'lib/gr.rb', line 2497

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

.inqclipxform ⇒ Object 



2231
2232
2233
 
# File 'lib/gr.rb', line 2231

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

.inqcolor(color) ⇒ Object 



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

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

.inqcolorfromrgb ⇒ Integer 



1545
1546
1547
1548
1549
 
# File 'lib/gr.rb', line 1545

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

.inqcolormap ⇒ Object

inqcolormap



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

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

.inqcolormapinds ⇒ Array

Inquire the color index range of the current colormap.



1528
1529
1530
1531
1532
 
# File 'lib/gr.rb', line 1528

def inqcolormapinds
  inquiry i[int int] do |first_color_ind, last_color_ind|
    super(first_color_ind, last_color_ind)
  end
end

.inqdspsize ⇒ Array

Get the current display size.

Depending on the current workstation type, the current display might be the primary screen (e.g. when using gksqt or GKSTerm) or a purely virtual display (e.g. when using Cairo). When a high DPI screen is used as the current display, width and height will be in logical pixels.



113
114
115
116
117
 
# File 'lib/gr.rb', line 113

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

.inqfillcolorind ⇒ Integer

Returns the current fill area color index.

This function gets the color of fill area output primitives.



808
809
810
 
# File 'lib/gr.rb', line 808

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

.inqfillintstyle ⇒ Integer

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

This function gets the currently set fill style.



767
768
769
 
# File 'lib/gr.rb', line 767

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

.inqfillstyle ⇒ Integer

Returns the current fill area color index.

This function gets the color index for PATTERN and HATCH fills.



789
790
791
 
# File 'lib/gr.rb', line 789

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

.inqlinecolorind ⇒ Object

Define the color of subsequent polyline output primitives.



518
519
520
 
# File 'lib/gr.rb', line 518

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

.inqlinetype ⇒ Object

Specify the line style for polylines.



493
494
495
 
# File 'lib/gr.rb', line 493

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

.inqlinewidth ⇒ 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.



508
509
510
 
# File 'lib/gr.rb', line 508

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

.inqmarkercolorind ⇒ Object

Define the color of subsequent polymarker output primitives.



594
595
596
 
# File 'lib/gr.rb', line 594

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

.inqmarkersize ⇒ Numeric

Inquire the marker size for polymarkers.



584
585
586
 
# File 'lib/gr.rb', line 584

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

.inqmarkertype ⇒ Object

Specify the marker type for polymarkers.

Polymarkers appear centered over their specified coordinates.



567
568
569
 
# File 'lib/gr.rb', line 567

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

.inqmathfont ⇒ Object 



2485
2486
2487
 
# File 'lib/gr.rb', line 2485

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

.inqmathtex(x, y, string) ⇒ Object

inqmathtex



1883
1884
1885
1886
1887
 
# File 'lib/gr.rb', line 1883

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.



2305
2306
2307
2308
2309
 
# File 'lib/gr.rb', line 2305

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

.inqperspectiveprojection ⇒ Object

Return the parameters for the perspective projection.



2262
2263
2264
2265
2266
 
# File 'lib/gr.rb', line 2262

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

.inqprojectiontype ⇒ Object

Return the projection type.



2246
2247
2248
 
# File 'lib/gr.rb', line 2246

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

.inqregenflags ⇒ Integer 




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

.inqresamplemethod ⇒ Integer

Inquire the resample method used for drawimage



2157
2158
2159
2160
2161
 
# File 'lib/gr.rb', line 2157

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

.inqresizebehaviour ⇒ Object 



814
815
816
 
# File 'lib/gr.rb', line 814

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

.inqscale ⇒ Object

inqscale



1014
1015
1016
 
# File 'lib/gr.rb', line 1014

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

.inqscalefactors3d ⇒ Object

Returns the scale factors for each axis.



2353
2354
2355
2356
2357
 
# File 'lib/gr.rb', line 2353

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

.inqspace ⇒ 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°.



982
983
984
985
986
 
# File 'lib/gr.rb', line 982

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

.inqtext(x, y, string) ⇒ Object

Draw a text at position x, y using the given options and current text attributes.

GR_TEXT_ENABLE_INLINE_MATH)

The values for x and y specify the text position. If the GR_TEXT_USE_WC option is set, they are interpreted as world coordinates, otherwise as normalized device coordinates. The string may contain new line characters and inline math expressions ($…$). The latter are only taken into account, if the GR_TEXT_ENABLE_INLINE_MATH option is set. 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.



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

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 



2378
2379
2380
2381
2382
 
# File 'lib/gr.rb', line 2378

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.



679
680
681
 
# File 'lib/gr.rb', line 679

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

.inqtextencoding ⇒ Object 



2386
2387
2388
2389
2390
 
# File 'lib/gr.rb', line 2386

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

.inqtextext(x, y, string) ⇒ Object

inqtextext



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

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

.inqtextx(x, y, string, opts) ⇒ Object 



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

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

.inqtransformationparameters ⇒ Object

Return the camera position, up vector and focus point.



2285
2286
2287
2288
2289
 
# File 'lib/gr.rb', line 2285

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

.inqviewport ⇒ Object

inqviewport



878
879
880
881
882
 
# File 'lib/gr.rb', line 878

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

.inqvolumeflags ⇒ Array

Inquire the parameters which can be set for cpubasedvolume. The size of the resulting image, the way the volumeborder is calculated and the amount of threads which are used.



2455
2456
2457
2458
2459
 
# File 'lib/gr.rb', line 2455

def inqvolumeflags
  inquiry([:int] * 5) do |*pts|
    super(*pts)
  end
end

.inqvpsize ⇒ Object

FIXME! (#61)



2464
2465
2466
2467
2468
 
# File 'lib/gr.rb', line 2464

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

.inqwindow ⇒ Object

inqwindow



851
852
853
854
855
 
# File 'lib/gr.rb', line 851

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

.inqwindow3d ⇒ Object

Return the three dimensional window.



2336
2337
2338
2339
2340
 
# File 'lib/gr.rb', line 2336

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.

flatten



2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
 
# File 'lib/gr.rb', line 2023

def interp2(x, y, z, xq, yq, method, extrapval)
  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

.loadfont(str) ⇒ Object

Load a font file from a given filename.

This function loads a font from a given absolute filename and assigns a font index to it. To use the loaded font call gr_settextfontprec using the resulting font index and precision 3.



2400
2401
2402
2403
2404
 
# File 'lib/gr.rb', line 2400

def loadfont(str)
  inquiry_int do |font|
    super(str, font)
  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.




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

.moveselection ⇒ Object 




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

.ndctowc(x, y) ⇒ Object 



1644
1645
1646
1647
1648
1649
1650
 
# File 'lib/gr.rb', line 1644

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.

Raises:

  • (ArgumentError) 


347
348
349
350
351
352
353
 
# File 'lib/gr.rb', line 347

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

  nx = dimx == x.length ? -dimx : dimx
  ny = dimy == y.length ? -dimy : dimy
  super(x, y, nx, ny, 1, 1, dimx, dimy, int(color))
end

.nonuniformpolarcellarray(phi, r, ncol, nrow, color) ⇒ Object

Display a two dimensional color index array mapped to a disk using polar coordinates with nonuniform cell sizes.

The mapping of the polar coordinates and the drawing is performed similar to gr_polarcellarray with the difference that the individual cell sizes are specified allowing nonuniform sized cells.

Raises:

  • (ArgumentError) 


414
415
416
417
418
419
420
 
# File 'lib/gr.rb', line 414

def nonuniformpolarcellarray(phi, r, ncol, nrow, color)
  raise ArgumentError unless (ncol..(ncol + 1)).include?(phi.length) && (nrow..(nrow + 1)).include?(r.length)

  dimphi = ncol == phi.length ? -ncol : ncol
  dimr = nrow == r.length ? -nrow : nrow
  super(0, 0, phi, r, dimphi, dimr, 1, 1, ncol, nrow, int(color))
end

.opengks ⇒ Object 




# File 'lib/gr.rb', line 101

.openws ⇒ Object

Open a graphical workstation.




# File 'lib/gr.rb', line 119

.panzoom(x, y, zoom) ⇒ Object

panzoom



2099
2100
2101
2102
2103
 
# File 'lib/gr.rb', line 2099

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.



2192
2193
2194
2195
 
# File 'lib/gr.rb', line 2192

def path(x, y, codes)
  n = equal_length(x, y)
  super(n, x, y, codes)
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.

The additional parameters to the function can be used to further control the mapping from polar to cartesian coordinates.

If rmin is greater than 0 the input data is mapped to a punctured disk (or annulus) with an inner radius of rmin and an outer radius rmax. If rmin is greater than rmax the Y-axis of the array is reversed.

The parameter phimin and phimax can be used to map the data to a sector of the (punctured) disk starting at phimin and ending at phimax. If phimin is greater than phimax the X-axis is reversed. The visible sector is the one starting in mathematically positive direction (counterclockwise) at the smaller angle and ending at the larger angle. An example of the four possible options can be found below:

  • phimin phimax Result

  • 90 270 Left half visible, mapped counterclockwise

  • 270 90 Left half visible, mapped clockwise

  • -90 90 Right half visible, mapped counterclockwise

  • 90 -90 Right half visible, mapped clockwise



397
398
399
 
# File 'lib/gr.rb', line 397

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

.polygonmesh3d(px, py, pz, connections, colors) ⇒ Object 



2470
2471
2472
2473
2474
 
# File 'lib/gr.rb', line 2470

def polygonmesh3d(px, py, pz, connections, colors)
  n_points = equal_length(px, py, pz)
  n_connections = colors.length
  super(n_points, px, py, pz, n_connections, int(connections), int(colors))
end

.polyline(x, y, linewidth = nil, line_z = nil) ⇒ Object

Draw a polyline using the current line attributes, 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 polyline are linetype, linewidth and color index.



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/gr.rb', line 191

def polyline(x, y, linewidth = nil, line_z = nil)
  # GR.jl - Multiple dispatch
  n = equal_length(x, y)
  if linewidth.nil? && line_z.nil?
    super(n, x, y)
  else
    linewidth ||= GR.inqlinewidth
    linewidth = if linewidth.is_a?(Numeric)
                  Array.new(n, linewidth * 100)
                else
                  raise ArgumentError if n != linewidth.length

                  linewidth.map { |i| (100 * i).round }
                end
    line_z ||= GR.inqcolor(989) # FIXME
    color = if line_z.is_a?(Numeric)
              Array.new(n, line_z)
            else
              raise ArgumentError if n != line_z.length

              to_rgb_color(line_z)
            end
    z = linewidth.to_a.zip(color).flatten # to_a : NArray
    gdp(x, y, GDP_DRAW_LINES, z)
  end
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.



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

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

.polymarker(x, y, markersize = nil, marker_z = nil) ⇒ Object

Draw marker symbols centered at the given data points.

The values for x and y are in world coordinates. The attributes that control the appearance of a polymarker are marker type, marker size scale factor and color index.



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'lib/gr.rb', line 229

def polymarker(x, y, markersize = nil, marker_z = nil)
  # GR.jl - Multiple dispatch
  n = equal_length(x, y)
  if markersize.nil? && marker_z.nil?
    super(n, x, y)
  else
    markersize ||= GR.inqmarkersize
    markersize = if markersize.is_a?(Numeric)
                   Array.new(n, markersize * 100)
                 else
                   raise ArgumentError if n != markersize.length

                   markersize.map { |i| (100 * i).round }
                 end
    marker_z ||= GR.inqcolor(989) # FIXME
    color = if marker_z.is_a?(Numeric)
              Array.new(n, marker_z)
            else
              raise ArgumentError if n != marker_z.length

              to_rgb_color(marker_z)
            end
    z = markersize.to_a.zip(color).flatten # to_a : NArray
    gdp(x, y, GDP_DRAW_MARKERS, z)
  end
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.



1319
1320
1321
1322
 
# File 'lib/gr.rb', line 1319

def polymarker3d(x, y, z)
  n = equal_length(x, y, z)
  super(n, x, y, z)
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.



1994
1995
1996
1997
1998
1999
2000
2001
2002
 
# File 'lib/gr.rb', line 1994

def quiver(x, y, u, v, color)
  nx = x.length
  ny = y.length
  if u.length != nx * ny || v.length != nx * ny
    raise ArgumentError, "u and v must have length nx * ny (expected #{nx * ny}, got u: #{u.length}, v: #{v.length})"
  end

  super(nx, ny, x, y, u, v, (color ? 1 : 0))
end

.readimage(path) ⇒ Integer 



1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
 
# File 'lib/gr.rb', line 1785

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, Fiddle::RUBY_FREE)
  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 




# File 'lib/gr.rb', line 953

.reducepoints(xd, yd, n) ⇒ Object

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



1950
1951
1952
1953
1954
1955
1956
 
# File 'lib/gr.rb', line 1950

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 



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

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

.restorestate ⇒ Object 




# File 'lib/gr.rb', line 1915

.savestate ⇒ Object 




# File 'lib/gr.rb', line 1913

.selectclipxform ⇒ Object 



2231
2232
2233
 
# File 'lib/gr.rb', line 2231

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

.selectcontext ⇒ Object 




# File 'lib/gr.rb', line 1917

.selntran ⇒ Object

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




# File 'lib/gr.rb', line 884

.setapproximativecalculation ⇒ Object

Set if gr_cpubasedvolume is calculated approximative or exact. To use the exact calculation set approximative_calculation to 0. The default value is the approximative version, which can be set with the number 1.




# File 'lib/gr.rb', line 2434

.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.




# File 'lib/gr.rb', line 1762

.setarrowstyle ⇒ Object

Set the arrow style to be used for subsequent arrow commands.

setarrowstyle defines the arrow style for subsequent arrow primitives.




# File 'lib/gr.rb', line 1736

.setbordercolorind ⇒ Object

Define the color of subsequent path output primitives.



2225
2226
2227
 
# File 'lib/gr.rb', line 2225

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

.setborderwidth ⇒ Object

Define the border width of subsequent path output primitives.



2215
2216
2217
 
# File 'lib/gr.rb', line 2215

def inqborderwidth
  inquiry_double { |pt| super(pt) }
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.




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

.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).




# File 'lib/gr.rb', line 683

.setcharspace ⇒ Object 




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

.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.




# File 'lib/gr.rb', line 704

.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.




# File 'lib/gr.rb', line 895

.setclipregion ⇒ Object 



2491
2492
2493
 
# File 'lib/gr.rb', line 2491

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

.setclipsector ⇒ Object 



2497
2498
2499
2500
2501
 
# File 'lib/gr.rb', line 2497

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

.setcolormap ⇒ Object

Set the currently used colormap.

Using a negative index will use the reverse of the selected colormap.




# File 'lib/gr.rb', line 1483

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

Note:

GR.jl and python-gr have different APIsI

Define a colormap by a list of RGB colors. This function defines a colormap using the n given color intensities. If less than 256 colors are provided the colors intensities are linear interpolated. If x is NULL the given color values are evenly distributed in the colormap. Otherwise the normalized value of x defines the position of the color in the colormap.



1514
1515
1516
1517
1518
1519
1520
1521
1522
 
# File 'lib/gr.rb', line 1514

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

Redefine an existing color index representation by specifying an RGB color triplet.




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

.setcoordxform(mat) ⇒ Object

Change the coordinate transformation according to the given matrix.



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

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.




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

.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.




# File 'lib/gr.rb', line 748

.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.




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

.setlinecolorind ⇒ Object

Define the color of subsequent polyline output primitives.



518
519
520
 
# File 'lib/gr.rb', line 518

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

.setlinetype ⇒ Object

Specify the line style for polylines.



493
494
495
 
# File 'lib/gr.rb', line 493

def inqlinetype
  inquiry_int { |pt| super(pt) }
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.



508
509
510
 
# File 'lib/gr.rb', line 508

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

.setmarkercolorind ⇒ Object

Define the color of subsequent polymarker output primitives.



594
595
596
 
# File 'lib/gr.rb', line 594

def inqmarkercolorind
  inquiry_int { |pt| super(pt) }
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.




# File 'lib/gr.rb', line 571

.setmarkertype ⇒ Object

Specify the marker type for polymarkers.

Polymarkers appear centered over their specified coordinates.



567
568
569
 
# File 'lib/gr.rb', line 567

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

.setmathfont ⇒ Object 



2485
2486
2487
 
# File 'lib/gr.rb', line 2485

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

.setorthographicprojection ⇒ Object

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




# File 'lib/gr.rb', line 2291

.setperspectiveprojection ⇒ Object

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




# File 'lib/gr.rb', line 2250

.setpicturesizeforvolume ⇒ Object

Set the width and height of the resulting picture. These values are only used for gr_volume and gr_cpubasedvolume. The default values are 1000 for both.




# File 'lib/gr.rb', line 2413

.setprojectiontype ⇒ Object

Set the projection type with this flag.




# File 'lib/gr.rb', line 2235

.setregenflags ⇒ Object 




# File 'lib/gr.rb', line 1908

.setresamplemethod ⇒ Object

Set the resample method used for drawimage.




# File 'lib/gr.rb', line 2105

.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.




# File 'lib/gr.rb', line 988

.setscalefactors3d ⇒ Object

Set the scale factor for each axis. A one means no scale. The scaling factors must not be zero. .




# File 'lib/gr.rb', line 2342

.setsegtran ⇒ Object 




# File 'lib/gr.rb', line 955

.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.




# File 'lib/gr.rb', line 1823

.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°.



982
983
984
985
986
 
# File 'lib/gr.rb', line 982

def inqspace
  inquiry i[double double int int] do |*pts|
    super(*pts)
  end
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 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.




# File 'lib/gr.rb', line 2359

.settextalign ⇒ Object

  • 1 : TEXT_HALIGN_LEFT - Left justify

  • 2 : TEXT_HALIGN_CENTER - Center justify

  • 3 : TEXT_HALIGN_RIGHT - Right justify

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.




# File 'lib/gr.rb', line 730

.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.




# File 'lib/gr.rb', line 664

.settextencoding ⇒ Object 



2386
2387
2388
2389
2390
 
# File 'lib/gr.rb', line 2386

def inqtextencoding
  inquiry_int do |encoding|
    super(encoding)
  end
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 using either native font rendering or FreeType. OUTLINE uses the GR path rendering functions to draw individual glyphs and produces the highest quality output.




# File 'lib/gr.rb', line 598

.settextpath ⇒ Object

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




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

.setthreadnumber ⇒ Object

Set the number of threads which can run parallel. The default value is the number of threads the cpu has.




# File 'lib/gr.rb', line 2406

.settransformationparameters ⇒ Object

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




# File 'lib/gr.rb', line 2268

.settransparency ⇒ Object

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




# File 'lib/gr.rb', line 1838

.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.




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

.setvolumebordercalculation(# @!method setthreadnumber) ⇒ Object

Set the gr_volume border type with this flag. This inflicts how the volume is calculated. When the flag is set to GR_VOLUME_WITH_BORDER the border will be calculated the same as the points inside the volume.




# File 'lib/gr.rb', line 2422

.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.




# File 'lib/gr.rb', line 828

.setwindow3d ⇒ Object

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




# File 'lib/gr.rb', line 2323

.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.




# File 'lib/gr.rb', line 931

.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.




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

.shade ⇒ Object

Note:

hexbin is overwritten by ‘require gr/plot`. The original method is moved to the underscored name. The yard document will show the method name after evacuation.




# File 'lib/gr.rb', line 2041

.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.



2086
2087
2088
2089
2090
 
# File 'lib/gr.rb', line 2086

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.



2063
2064
2065
2066
2067
 
# File 'lib/gr.rb', line 2063

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.



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

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

.startlistener ⇒ Integer 



2477
2478
2479
2480
2481
 
# File 'lib/gr.rb', line 2477

def startlistener
  inquiry_int do |ret|
    super(ret)
  end
end

.surface(x, y, z, option) ⇒ Object

Note:

surface is overwritten by ‘require gr/plot`. The original method is moved to the underscored name. The yard document will show the method name after evacuation.

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:

Raises:

  • (ArgumentError) 


1396
1397
1398
1399
1400
1401
1402
 
# File 'lib/gr.rb', line 1396

def surface(x, y, z, option)
  nx = x.length
  ny = y.length
  raise ArgumentError, "z must have length nx * ny (expected #{nx * ny}, got #{z.length})" if z.length != nx * ny

  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.




# File 'lib/gr.rb', line 256

.text3d ⇒ Object 



2378
2379
2380
2381
2382
 
# File 'lib/gr.rb', line 2378

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

.text_maxsize ⇒ Object 




# File 'lib/gr.rb', line 1906

.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 mathtex function.




# File 'lib/gr.rb', line 1018

.textx ⇒ Object

Draw a text at position x, y using the given options and current text attributes.

GR_TEXT_ENABLE_INLINE_MATH)

The values for x and y specify the text position. If the GR_TEXT_USE_WC option is set, they are interpreted as world coordinates, otherwise as normalized device coordinates. The string may contain new line characters and inline math expressions ($…$). The latter are only taken into account, if the GR_TEXT_ENABLE_INLINE_MATH option is set. 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.



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

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

.tick ⇒ Numeric 




# File 'lib/gr.rb', line 1551

.titles3d ⇒ Object

Display axis titles just outside of their respective axes.




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

.to_rgb_color(z) ⇒ Array, NArray 



2199
2200
2201
2202
2203
2204
2205
2206
2207
 
# File 'lib/gr.rb', line 2199

def to_rgb_color(z)
  zmin, zmax = z.minmax
  return Array.new(z.length, 0) if zmax == zmin

  z.map  do |i|
    zi = (i - zmin) / (zmax - zmin).to_f
    inqcolor(1000 + (zi * 255).round)
  end
end

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

Draw a contour plot for the given triangle mesh.



1467
1468
1469
1470
1471
 
# File 'lib/gr.rb', line 1467

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

.trisurface(x, y, z) ⇒ Object

Draw a triangular surface plot for the given data points.



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

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

.updategks ⇒ Object 




# File 'lib/gr.rb', line 961

.updatews ⇒ Object

Update the specified workstation.




# File 'lib/gr.rb', line 175

.uselinespec ⇒ Integer 



1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
 
# File 'lib/gr.rb', line 1924

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, Fiddle::RUBY_FREE)
  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

.validaterange ⇒ Integer 



1557
1558
1559
1560
1561
1562
1563
 
# File 'lib/gr.rb', line 1557

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

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

Draw a standard vertical error bar graph.



1276
1277
1278
1279
 
# File 'lib/gr.rb', line 1276

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.



2037
2038
2039
 
# File 'lib/gr.rb', line 2037

def version
  super.to_s
end

.wc3towc(x, y, z) ⇒ Object 



1660
1661
1662
1663
1664
1665
1666
1667
 
# File 'lib/gr.rb', line 1660

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 



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

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