gr Reference¶
Output Functions¶
- gr.polyline(x, y)[source]¶
Draw a polyline using the current line attributes, starting from the first data point and ending at the last data point.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
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.
- gr.polymarker(x, y)[source]¶
Draw marker symbols centered at the given data points.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
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.
- gr.text(x, y, string)[source]¶
Draw a text at position x, y using the current text attributes.
Parameters:
- x :
The X coordinate of starting position of the text string
- y :
The Y coordinate of starting position of the text string
- string :
The text to be drawn
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.
- gr.fillarea(x, y)[source]¶
Allows you to specify a polygonal shape of an area to be filled.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
The attributes that control the appearance of fill areas are fill area interior style, fill area style index and fill area color index.
- gr.cellarray(xmin, xmax, ymin, ymax, dimx, dimy, color)[source]¶
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.
Parameters:
- xmin, ymin :
Lower left point of the rectangle
- xmax, ymax :
Upper right point of the rectangle
- dimx, dimy :
X and Y dimension of the color index array
- color :
Color index array
The values for xmin, xmax, ymin and ymax are in world coordinates.
- gr.shadepoints(x, y, dims=(1200, 1200), xform=1)[source]¶
Display a point set as an aggregated and rasterized image using the current GR colormap.
Parameters:
- x :
A pointer to the X coordinates
- y :
A pointer to the Y coordinates
- dims :
The size of the grid used for rasterization
- xform :
The transformation type used for color mapping
The values for x and y are in world coordinates.
The available transformation types are:
XFORM_BOOLEAN
0
boolean
XFORM_LINEAR
1
linear
XFORM_LOG
2
logarithmic
XFORM_LOGLOG
3
double logarithmic
XFORM_CUBIC
4
cubic
XFORM_EQUALIZED
5
histogram equalized
- gr.shadelines(x, y, dims=(1200, 1200), xform=1)[source]¶
Display a line set as an aggregated and rasterized image using the current GR colormap.
Parameters:
- x :
A pointer to the X coordinates
- y :
A pointer to the Y coordinates
- dims :
The size of the grid used for rasterization
- xform :
The transformation type used for color mapping
The values for x and y are in world coordinates. NaN values can be used to separate the point set into line segments.
The available transformation types are:
XFORM_BOOLEAN
0
boolean
XFORM_LINEAR
1
linear
XFORM_LOG
2
logarithmic
XFORM_LOGLOG
3
double logarithmic
XFORM_CUBIC
4
cubic
XFORM_EQUALIZED
5
histogram equalized
- gr.spline(px, py, m, method)[source]¶
Generate a cubic spline-fit, starting from the first data point and ending at the last data point.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
- m :
The number of points in the polygon to be drawn (m > len(x))
- method :
The smoothing method
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.
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.
- gr.textext(x, y, string)[source]¶
Draw a text at position x, y using the current text attributes. Strings can be defined to create basic mathematical expressions and Greek letters.
Parameters:
- x :
The X coordinate of starting position of the text string
- y :
The Y coordinate of starting position of the text string
- string :
The text to be drawn
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.
Letter
Keyword
Α α
alpha
Β β
beta
Γ γ
gamma
Δ δ
delta
Ε ε
epsilon
Ζ ζ
zeta
Η η
eta
Θ θ
theta
Ι ι
iota
Κ κ
kappa
Λ λ
lambda
Μ μ
mu
Ν ν
Nu / v
Ξ ξ
xi
Ο ο
omicron
Π π
pi
Ρ ρ
rho
Σ σ
sigma
Τ τ
tau
Υ υ
upsilon
Φ φ
phi
Χ χ
chi
Ψ ψ
psi
Ω ω
omega
Note:
v
is a replacement fornu
which would conflict withn
(newline)For more sophisticated mathematical formulas, you should use the gr.mathtex function.
- gr.axes(x_tick, y_tick, x_org, y_org, major_x, major_y, tick_size)[source]¶
Draw X and Y coordinate axes with linearly and/or logarithmically spaced tick marks.
Parameters:
- x_tick, y_tick :
The interval between minor tick marks on each axis.
- x_org, y_org :
The world coordinates of the origin (point of intersection) of the X and Y axes.
- major_x, major_y :
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 :
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).
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.
- gr.grid(x_tick, y_tick, x_org, y_org, major_x, major_y)[source]¶
Draw a linear and/or logarithmic grid.
Parameters:
- x_tick, y_tick :
The length in world coordinates of the interval between minor grid lines.
- x_org, y_org :
The world coordinates of the origin (point of intersection) of the grid.
- major_x, major_y :
Unitless integer values specifying the number of minor grid lines between major grid lines. Values of 0 or 1 imply no grid lines.
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.
- gr.verrorbars(px, py, e1, e2)[source]¶
Draw a standard vertical error bar graph.
Parameters:
- px :
A list of length N containing the X coordinates
- py :
A list of length N containing the Y coordinates
- e1 :
The absolute values of the lower error bar data
- e2 :
The absolute values of the upper error bar data
- gr.herrorbars(px, py, e1, e2)[source]¶
Draw a standard horizontal error bar graph.
Parameters:
- px :
A list of length N containing the X coordinates
- py :
A list of length N containing the Y coordinates
- e1 :
The absolute values of the lower error bar data
- e2 :
The absolute values of the upper error bar data
- gr.polyline3d(px, py, pz)[source]¶
Draw a 3D curve using the current line attributes, starting from the first data point and ending at the last data point.
Parameters:
- x :
A list of length N containing the X coordinates
- y :
A list of length N containing the Y coordinates
- z :
A list of length N containing the Z coordinates
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.
- gr.axes3d(x_tick, y_tick, z_tick, x_org, y_org, z_org, major_x, major_y, major_z, tick_size)[source]¶
Draw X, Y and Z coordinate axes with linearly and/or logarithmically spaced tick marks.
Parameters:
- x_tick, y_tick, z_tick :
The interval between minor tick marks on each axis.
- x_org, y_org, z_org :
The world coordinates of the origin (point of intersection) of the X and Y axes.
- major_x, major_y, major_z :
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 :
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).
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.
- gr.titles3d(x_title, y_title, z_title)[source]¶
Display axis titles just outside of their respective axes.
Parameters:
- x_title, y_title, z_title :
The text to be displayed on each axis
- gr.volume(data, algorithm=0, dmin=-1, dmax=-1)[source]¶
Draw volume data using the given algorithm and apply the current GR colormap. Returns the minimum and maximum data value that were used when applying the colormap.
Parameters:
- data :
3D numpy array containing the intensities for each point
- algorithm :
The algorithm used to reduce the volume data
- dmin :
The minimum data value when applying the colormap. If it is negative, the actual occurring minimum is used.
- dmax :
The maximum data value when applying the colormap. If it is negative, the actual occurring maximum is used.
Available algorithms are:
VOLUME_EMISSION
0
emission model
VOLUME_ABSORPTION
1
absorption model
VOLUME_MIP
2
maximum intensity projection
- gr.surface(px, py, pz, option)[source]¶
Draw a three-dimensional surface plot for the given data points.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
- z :
A list of length len(x) * len(y) or an appropriately dimensioned array containing the Z coordinates
- option :
Surface display option (see table below)
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 following table:
LINES
0
Use X Y polylines to denote the surface
MESH
1
Use a wire grid to denote the surface
FILLED_MESH
2
Applies an opaque grid to the surface
Z_SHADED_MESH
3
Applies Z-value shading to the surface
COLORED_MESH
4
Applies a colored grid to the surface
CELL_ARRAY
5
Applies a grid of individually-colored cells to the surface
SHADED_MESH
6
Applies light source shading to the 3-D surface
- gr.contour(px, py, h, pz, major_h)[source]¶
Draw contours of a three-dimensional data set whose values are specified over a rectangular mesh. Contour lines may optionally be labeled.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
- h :
A list containing the Z coordinate for the height values
- z :
A list of length len(x) * len(y) or an appropriately dimensioned array containing the Z coordinates
- major_h :
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.
- gr.drawrect(xmin, xmax, ymin, ymax)[source]¶
Draw a rectangle using the current line attributes.
Parameters:
- xmin :
Lower left edge of the rectangle
- xmax :
Lower right edge of the rectangle
- ymin :
Upper left edge of the rectangle
- ymax :
Upper right edge of the rectangle
- gr.fillrect(xmin, xmax, ymin, ymax)[source]¶
Draw a filled rectangle using the current fill attributes.
Parameters:
- xmin :
Lower left edge of the rectangle
- xmax :
Lower right edge of the rectangle
- ymin :
Upper left edge of the rectangle
- ymax :
Upper right edge of the rectangle
- gr.drawarc(xmin, xmax, ymin, ymax, a1, a2)[source]¶
Draw a circular or elliptical arc covering the specified rectangle.
Parameters:
- xmin :
Lower left edge of the rectangle
- xmax :
Lower right edge of the rectangle
- ymin :
Upper left edge of the rectangle
- ymax :
Upper right edge of the rectangle
- a1 :
The start angle
- a2 :
The end angle
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.
- gr.fillarc(xmin, xmax, ymin, ymax, a1, a2)[source]¶
Fill a circular or elliptical arc covering the specified rectangle.
Parameters:
- xmin :
Lower left edge of the rectangle
- xmax :
Lower right edge of the rectangle
- ymin :
Upper left edge of the rectangle
- ymax :
Upper right edge of the rectangle
- a1 :
The start angle
- a2 :
The end angle
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.
- gr.drawarrow(x1, y1, x2, y2)[source]¶
Draw an arrow between two points.
Parameters:
- x1, y1 :
Starting point of the arrow (tail)
- x2, y2 :
Head of the arrow
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.
- gr.drawimage(xmin, xmax, ymin, ymax, width, height, data, model=0)[source]¶
Draw an image into a given rectangular area.
Parameters:
- xmin, ymin :
First corner point of the rectangle
- xmax, ymax :
Second corner point of the rectangle
- width, height :
The width and the height of the image
- data :
An array of color values dimensioned width by height
- model :
Color model (default=0)
The available color models are:
MODEL_RGB
0
AABBGGRR
MODEL_HSV
1
AAVVSSHH
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.
- gr.mathtex(x, y, string)[source]¶
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, y :
Position of the text string specified in world coordinates
- string :
The text string to be drawn
- gr.path(x, y, codes)[source]¶
Draw paths using the given vertices and path codes.
Parameters:
- x :
A list containing the X coordinates
- y :
A list containing the Y coordinates
- codes :
A list containing the path codes
The values for x and y are in world coordinates. The codes describe several path primitives that can be used to create compound paths.
The following path codes are recognized:
Code
Description
x
y
M, m
move
x
y
L, l
line
x
y
Q, q
quadratic Bezier
x1, x2
y1, y2
C, c
cubic Bezier
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
Move: M, m
Moves the current position to (x, y). The new position is either absolute (M) or relative to the current position (m). The initial position of
gr.path()
is (0, 0).Example:
>>> gr.path([0.5, -0.1], [0.2, 0.1], "Mm")
The first move command in this example moves the current position to the absolute coordinates (0.5, 0.2). The second move to performs a movement by (-0.1, 0.1) relative to the current position resulting in the point (0.4, 0.3).
Line: L, l
Draws a line from the current position to the given position (x, y). The end point of the line is either absolute (L) or relative to the current position (l). The current position is set to the end point of the line.
Example:
>>> gr.path([0.1, 0.5, 0.0], [0.1, 0.1, 0.2], "MLlS")
The first line to command draws a straight line from the current position (0.1, 0.1) to the absolute position (0.5, 0.1) resulting in a horizontal line. The second line to command draws a vertical line relative to the current position resulting in the end point (0.5, 0.3).
Quadratic Bezier curve: Q, q
Draws a quadratic bezier curve from the current position to the end point (x2, y2) using (x1, y1) as the control point. Both points are either absolute (Q) or relative to the current position (q). The current position is set to the end point of the bezier curve.
Example:
>>> gr.path([0.1, 0.3, 0.5, 0.2, 0.4], [0.1, 0.2, 0.1, 0.1, 0.0], "MQqS")
This example will generate two bezier curves whose start and end points are each located at y=0.1. As the control points are horizontally in the middle of each bezier curve with a higher y value both curves are symmetrical and bend slightly upwards in the middle. The current position is set to (0.9, 0.1) at the end.
Cubic Bezier curve: C, c
Draws a cubic bezier curve from the current position to the end point (x3, y3) using (x1, y1) and (x2, y2) as the control points. All three points are either absolute (C) or relative to the current position (c). The current position is set to the end point of the bezier curve.
Example:
>>> gr.path( ... [0.1, 0.2, 0.3, 0.4, 0.1, 0.2, 0.3], ... [0.1, 0.2, 0.0, 0.1, 0.1, -0.1, 0.0], ... "MCcS" ... )
This example will generate two bezier curves whose start and end points are each located at y=0.1. As the control points are equally spaced along the x-axis and the first is above and the second is below the start and end points this creates a wave-like shape for both bezier curves. The current position is set to (0.8, 0.1) at the end.
Ellipctical arc: A, a
Draws an elliptical arc starting at the current position. The major axis of the ellipse is aligned with the x-axis and the minor axis is aligned with the y-axis of the plot. rx and ry are the ellipses radii along the major and minor axis. a1 and a2 define the start and end angle of the arc in radians. The current position is set to the end point of the arc. If a2 is greater than a1 the arc is drawn counter-clockwise, otherwise it is drawn clockwise. The a and A commands draw the same arc. The third coordinates of the x and y array are ignored and reserved for future use.
Examples:
>>> gr.path([0.1, 0.2, -3.14159 / 2, 0.0], [0.1, 0.4, 3.14159 / 2, 0.0], "MAS")
This example draws an arc starting at (0.1, 0.1). As the start angle -pi/2 is smaller than the end angle pi/2 the arc is drawn counter-clockwise. In this case the right half of an ellipse with an x radius of 0.2 and a y radius of 0.4 is shown. Therefore the current position is set to (0.1, 0.9) at the end.
>>> gr.path([0.1, 0.2, 3.14159 / 2, 0.0], [0.9, 0.4, -3.14159 / 2, 0.0], "MAS")
This examples draws the same arc as the previous one. The only difference is that the starting point is now at (0.1, 0.9) and the start angle pi/2 is greater than the end angle -pi/2 so that the ellipse arc is drawn clockwise. Therefore the current position is set to (0.1, 0.1) at the end.
Close path: Z
Closes the current path by connecting the current position to the target position of the last move command (m or M) with a straight line. If no move to was performed in this path it connects the current position to (0, 0). When the path is stroked this line will also be drawn.
Stroke path: S, s
Strokes the path with the current border width and border color (set with
gr.setborderwidth()
andgr.setbordercolorind()
). In case of s the path is closed beforehand, which is equivalent to ZS.Fill path: F, f
Fills the current path using the even-odd-rule using the current fill color. Filling a path implicitly closes the path. The fill color can be set using
gr.setfillcolorind()
. In case of F the path is also stroked using the current border width and color afterwards.
This function requires GR runtime version 0.45 or higher.
Attribute Functions¶
- gr.setlinetype(style)[source]¶
Specify the line style for polylines.
Parameters:
- style :
The polyline line style
The available line types are:
LINETYPE_SOLID
1
Solid line
LINETYPE_DASHED
2
Dashed line
LINETYPE_DOTTED
3
Dotted line
LINETYPE_DASHED_DOTTED
4
Dashed-dotted line
LINETYPE_DASH_2_DOT
-1
Sequence of one dash followed by two dots
LINETYPE_DASH_3_DOT
-2
Sequence of one dash followed by three dots
LINETYPE_LONG_DASH
-3
Sequence of long dashes
LINETYPE_LONG_SHORT_DASH
-4
Sequence of a long dash followed by a short dash
LINETYPE_SPACED_DASH
-5
Sequence of dashes double spaced
LINETYPE_SPACED_DOT
-6
Sequence of dots double spaced
LINETYPE_DOUBLE_DOT
-7
Sequence of pairs of dots
LINETYPE_TRIPLE_DOT
-8
Sequence of groups of three dots
- gr.setlinewidth(width)[source]¶
Define the line width of subsequent polyline output primitives.
Parameters:
- width :
The polyline line width scale factor
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.
- gr.setlinecolorind(color)[source]¶
Define the color of subsequent polyline output primitives.
Parameters:
- color :
The polyline color index (COLOR < 1256)
- gr.setmarkertype(style)[source]¶
Specifiy the marker type for polymarkers.
Parameters:
- style :
The polymarker marker type
The available marker types are:
MARKERTYPE_DOT
1
Smallest displayable dot
MARKERTYPE_PLUS
2
Plus sign
MARKERTYPE_ASTERISK
3
Asterisk
MARKERTYPE_CIRCLE
4
Hollow circle
MARKERTYPE_DIAGONAL_CROSS
5
Diagonal cross
MARKERTYPE_SOLID_CIRCLE
-1
Filled circle
MARKERTYPE_TRIANGLE_UP
-2
Hollow triangle pointing upward
MARKERTYPE_SOLID_TRI_UP
-3
Filled triangle pointing upward
MARKERTYPE_TRIANGLE_DOWN
-4
Hollow triangle pointing downward
MARKERTYPE_SOLID_TRI_DOWN
-5
Filled triangle pointing downward
MARKERTYPE_SQUARE
-6
Hollow square
MARKERTYPE_SOLID_SQUARE
-7
Filled square
MARKERTYPE_BOWTIE
-8
Hollow bowtie
MARKERTYPE_SOLID_BOWTIE
-9
Filled bowtie
MARKERTYPE_HGLASS
-10
Hollow hourglass
MARKERTYPE_SOLID_HGLASS
-11
Filled hourglass
MARKERTYPE_DIAMOND
-12
Hollow diamond
MARKERTYPE_SOLID_DIAMOND
-13
Filled Diamond
MARKERTYPE_STAR
-14
Hollow star
MARKERTYPE_SOLID_STAR
-15
Filled Star
MARKERTYPE_TRI_UP_DOWN
-16
Hollow triangles pointing up and down overlaid
MARKERTYPE_SOLID_TRI_RIGHT
-17
Filled triangle point right
MARKERTYPE_SOLID_TRI_LEFT
-18
Filled triangle pointing left
MARKERTYPE_HOLLOW PLUS
-19
Hollow plus sign
MARKERTYPE_SOLID PLUS
-20
Solid plus sign
MARKERTYPE_PENTAGON
-21
Pentagon
MARKERTYPE_HEXAGON
-22
Hexagon
MARKERTYPE_HEPTAGON
-23
Heptagon
MARKERTYPE_OCTAGON
-24
Octagon
MARKERTYPE_STAR_4
-25
4-pointed star
MARKERTYPE_STAR_5
-26
5-pointed star (pentagram)
MARKERTYPE_STAR_6
-27
6-pointed star (hexagram)
MARKERTYPE_STAR_7
-28
7-pointed star (heptagram)
MARKERTYPE_STAR_8
-29
8-pointed star (octagram)
MARKERTYPE_VLINE
-30
verical line
MARKERTYPE_HLINE
-31
horizontal line
MARKERTYPE_OMARK
-32
o-mark
Polymarkers appear centered over their specified coordinates.
- gr.setmarkersize(size)[source]¶
Specify the marker size for polymarkers.
Parameters:
- size :
Scale factor applied to the nominal marker size
The polymarker size is calculated as the nominal size generated on the graphics device multiplied by the marker size scale factor.
- gr.inqmarkersize()[source]¶
Inquire the marker size for polymarkers.
This function requires GR runtime version 0.41.5.post47 or higher.
- gr.setmarkercolorind(color)[source]¶
Define the color of subsequent polymarker output primitives.
Parameters:
- color :
The polymarker color index (COLOR < 1256)
- gr.settextfontprec(font, precision)[source]¶
Specify the text font and precision for subsequent text output primitives.
Parameters:
- font :
Text font (see tables below)
- precision :
Text precision (see table below)
The available text fonts are:
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
FONT_COMPUTERMODERN
232
FONT_DEJAVUSANS
233
The available text precisions are:
TEXT_PRECISION_STRING
0
String precision (higher quality)
TEXT_PRECISION_CHAR
1
Character precision (medium quality)
TEXT_PRECISION_STROKE
2
Stroke precision (lower quality)
TEXT_PRECISION_OUTLINE
3
Outline precision (highest quality)
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 high 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.
- gr.setcharexpan(factor)[source]¶
Set the current character expansion factor (width to height ratio).
Parameters:
- factor :
Text expansion factor applied to the nominal text 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.
- gr.settextcolorind(color)[source]¶
Sets the current text color index.
Parameters:
- color :
The text color index (COLOR < 1256)
settextcolorind defines the color of subsequent text output primitives. GR uses the default foreground color (black=1) for the default text color index.
- gr.setcharheight(height)[source]¶
Set the current character height.
Parameters:
- height :
Text height value
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).
- gr.setcharup(ux, uy)[source]¶
Set the current character text angle up vector.
Parameters:
- ux, uy :
Text 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.
- gr.settextpath(path)[source]¶
Define the current direction in which subsequent text will be drawn.
Parameters:
- path :
Text path (see table below)
TEXT_PATH_RIGHT
0
left-to-right
TEXT_PATH_LEFT
1
right-to-left
TEXT_PATH_UP
2
downside-up
TEXT_PATH_DOWN
3
upside-down
- gr.settextalign(horizontal, vertical)[source]¶
Set the current horizontal and vertical alignment for text.
Parameters:
- horizontal :
Horizontal text alignment (see the table below)
- vertical :
Vertical text alignment (see the table below)
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.
TEXT_HALIGN_NORMAL
0
TEXT_HALIGN_LEFT
1
Left justify
TEXT_HALIGN_CENTER
2
Center justify
TEXT_HALIGN_RIGHT
3
Right justify
TEXT_VALIGN_NORMAL
0
TEXT_VALIGN_TOP
1
Align with the top of the characters
TEXT_VALIGN_CAP
2
Aligned with the cap of the characters
TEXT_VALIGN_HALF
3
Aligned with the half line of the characters
TEXT_VALIGN_BASE
4
Aligned with the base line of the characters
TEXT_VALIGN_BOTTOM
5
Aligned with the bottom line of the characters
- gr.setfillintstyle(style)[source]¶
Set the fill area interior style to be used for fill areas.
Parameters:
- style :
The style of fill to be used
setfillintstyle defines the interior style for subsequent fill area output primitives. The default interior style is HOLLOW.
HOLLOW
0
No filling. Just draw the bounding polyline
SOLID
1
Fill the interior of the polygon using the fill color index
PATTERN
2
Fill the interior of the polygon using the style index as a pattern index
HATCH
3
Fill the interior of the polygon using the style index as a cross-hatched style
- gr.setfillstyle(index)[source]¶
Sets the fill style to be used for subsequent fill areas.
Parameters:
- index :
The fill style index to be used
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.
- gr.setfillcolorind(color)[source]¶
Sets the current fill area color index.
Parameters:
- color :
The fill area color index (COLOR < 1256)
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.
- gr.setcolorrep(index, red, green, blue)[source]¶
setcolorrep allows to redefine an existing color index representation by specifying an RGB color triplet.
Parameters:
- index :
Color index in the range 0 to 1256
- red :
Red intensity in the range 0.0 to 1.0
- green :
Green intensity in the range 0.0 to 1.0
- blue:
Blue intensity in the range 0.0 to 1.0
- gr.setcolormap(index)[source]¶
Set the current GR colormap.
Parameters:
- index :
The colormap index, e.g. one of the gr.COLORMAP_* constants
For a list of built-in colormaps, see https://gr-framework.org/colormaps.html.
- gr.setcolormapfromrgb(colors, positions=None)[source]¶
Define a linear interpolated colormap by a list of RGB colors.
Parameters:
- colors :
A list of RGB tuples containing the normalized color intensities
- positions :
An optional list of length len(colors) containing the normalized positions where the corresponding colors are applied. The first element must be 0.0, the last element 1.0.
If no positions are given the colors are evenly distributed in the linear interpolated colormap. Otherwise the values of positions define the particular position of the color in the colormap.
- gr.setarrowstyle(style)[source]¶
Set the arrow style to be used for subsequent arrow commands.
Parameters:
- style :
The arrow style to be used
setarrowstyle defines the arrow style for subsequent arrow primitives. 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
- gr.setshadow(offsetx, offsety, blur)[source]¶
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 :
An x-offset, which specifies how far in the horizontal direction the shadow is offset from the object
- offsety :
A y-offset, which specifies how far in the vertical direction the shadow is offset from the object
- blur :
A blur value, which specifies whether the object has a hard or a diffuse edge
- gr.settransparency(alpha)[source]¶
Set the value of the alpha component associated with GR colors.
Parameters:
- alpha :
An alpha value (0.0 - 1.0)
- gr.setresamplemethod(resample_method)[source]¶
Set the resample method used for gr.drawimage().
- Parameters:
resample_method – the new resample method
The available options are:
RESAMPLE_DEFAULT
0x00000000
default
RESAMPLE_NEAREST
0x01010101
nearest neighbour
RESAMPLE_LINEAR
0x02020202
linear
RESAMPLE_LANCZOS
0x03030303
Lanczos
Alternatively, combinations of these methods can be selected for horizontal or vertical upsampling or downsampling:
UPSAMPLE_VERTICAL_DEFAULT
0x00000000
default for vertical upsampling
UPSAMPLE_HORIZONTAL_DEFAULT
0x00000000
default for horizontal upsampling
DOWNSAMPLE_VERTICAL_DEFAULT
0x00000000
default for vertical downsampling
DOWNSAMPLE_HORIZONTAL_DEFAULT
0x00000000
default for horizontal downsampling
UPSAMPLE_VERTICAL_NEAREST
0x00000001
nearest neighbor for vertical upsampling
UPSAMPLE_HORIZONTAL_NEAREST
0x00000100
nearest neighbor for horizontal upsampling
DOWNSAMPLE_VERTICAL_NEAREST
0x00010000
nearest neighbor for vertical downsampling
DOWNSAMPLE_HORIZONTAL_NEAREST
0x01000000
nearest neighbor for horizontal downsampling
UPSAMPLE_VERTICAL_LINEAR
0x00000002
linear for vertical upsampling
UPSAMPLE_HORIZONTAL_LINEAR
0x00000200
linear for horizontal upsampling
DOWNSAMPLE_VERTICAL_LINEAR
0x00020000
linear for vertical downsampling
DOWNSAMPLE_HORIZONTAL_LINEAR
0x02000000
linear for horizontal downsampling
UPSAMPLE_VERTICAL_LANCZOS
0x00000003
lanczos for vertical upsampling
UPSAMPLE_HORIZONTAL_LANCZOS
0x00000300
lanczos for horizontal upsampling
DOWNSAMPLE_VERTICAL_LANCZOS
0x00030000
lanczos for vertical downsampling
DOWNSAMPLE_HORIZONTAL_LANCZOS
0x03000000
lanczos for horizontal downsampling
This function requires GR runtime version 0.41.5.post43 or higher.
- gr.inqresamplemethod()[source]¶
Inquire the resample method used for gr.drawimage().
- Returns:
the current resample method
This function requires GR runtime version 0.41.5.post43 or higher.
- gr.setbordercolorind(color)[source]¶
Defines the color of subsequent path borders.
Parameters:
- color :
The border color index (COLOR < 1256)
This function requires GR runtime version 0.45 or higher.
- gr.inqbordercolorind()[source]¶
Returns the color index of path borders.
This function requires GR runtime version 0.45 or higher.
Transformation Functions¶
- gr.setscale(options)[source]¶
setscale sets the type of transformation to be used for subsequent GR output primitives.
Parameters:
- options :
Scale specification (see Table below)
OPTION_X_LOG
Logarithmic X-axis
OPTION_Y_LOG
Logarithmic Y-axis
OPTION_Z_LOG
Logarithmic Z-axis
OPTION_FLIP_X
Flip X-axis
OPTION_FLIP_Y
Flip Y-axis
OPTION_FLIP_Z
Flip Z-axis
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.
- gr.setwindow(xmin, xmax, ymin, ymax)[source]¶
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.
Parameters:
- xmin :
The left horizontal coordinate of the window (xmin < xmax).
- xmax :
The right horizontal coordinate of the window.
- ymin :
The bottom vertical coordinate of the window (ymin < ymax).
- ymax :
The top vertical coordinate of the window.
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.
- gr.setviewport(xmin, xmax, ymin, ymax)[source]¶
setviewport establishes a rectangular subspace of normalized device coordinates.
Parameters:
- xmin :
The left horizontal coordinate of the viewport.
- xmax :
The right horizontal coordinate of the viewport (0 <= xmin < xmax <= 1).
- ymin :
The bottom vertical coordinate of the viewport.
- ymax :
The top vertical coordinate of the viewport (0 <= ymin < ymax <= 1).
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.
- gr.selntran(transform)[source]¶
selntran selects a predefined transformation from world coordinates to normalized device coordinates.
Parameters:
- transform :
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
- gr.setclip(indicator)[source]¶
Set the clipping indicator.
Parameters:
- indicator :
An indicator specifying whether clipping is on or off.
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.
- gr.setwswindow(xmin, xmax, ymin, ymax)[source]¶
Set the area of the NDC viewport that is to be drawn in the workstation window.
Parameters:
- xmin :
The left horizontal coordinate of the workstation window.
- xmax :
The right horizontal coordinate of the workstation window (0 <= xmin < xmax <= 1).
- ymin :
The bottom vertical coordinate of the workstation window.
- ymax :
The top vertical coordinate of the workstation window (0 <= ymin < ymax <= 1).
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.
- gr.setwsviewport(xmin, xmax, ymin, ymax)[source]¶
Define the size of the workstation graphics window in meters.
Parameters:
- xmin :
The left horizontal coordinate of the workstation viewport.
- xmax :
The right horizontal coordinate of the workstation viewport.
- ymin :
The bottom vertical coordinate of the workstation viewport.
- ymax :
The top vertical coordinate of the workstation viewport.
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.
- gr.setspace(zmin, zmax, rotation, tilt)[source]¶
Set the abstract Z-space used for mapping three-dimensional output primitives into the current world coordinate space.
Parameters:
- zmin :
Minimum value for the Z-axis.
- zmax :
Maximum value for the Z-axis.
- rotation :
Angle for the rotation of the X axis, in degrees.
- tilt :
Viewing angle of the Z axis in degrees.
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°.
- gr.setcoordxform(mat)[source]¶
Change the coordinate transformation according to the given matrix.
Parameters:
- mat[3][2] :
2D transformation matrix
- gr.setprojectiontype(projection_type)[source]¶
Set the projection type with this flag.
- projection_type :
Projection type
The available options are:
PROJECTION_DEFAULT
0
default
PROJECTION_ORTHOGRAPHIC
1
orthographic
PROJECTION_PERSPECTIVE
2
perspective
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.inqprojectiontype()[source]¶
Return the projection type.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.setperspectiveprojection(near_plane, far_plane, fov)[source]¶
Set the far and near clipping planes and the vertical field of view.
Parameters:
- near_plane :
distance to near clipping plane
- far_plane :
distance to far clipping plane
- fov :
vertical field of view, must be between 0 and 180 degrees
Switches projection type to perspective.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.inqperspectiveprojection()[source]¶
Return the parameters for the perspective projection.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.setorthographicprojection(left, right, bottom, top, near_plane, far_plane)[source]¶
Set parameters for orthographic transformation.
Parameters:
- left :
xmin of the volume in world coordinates
- right :
xmax of volume in world coordinates
- bottom :
ymin of volume in world coordinates
- top :
ymax of volume in world coordinates
- near_plane :
distance to near clipping plane
- far_plane :
distance to far clipping plane
Switches projection type to orthographic.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.inqorthographicprojection()[source]¶
Return the parameters for the orthographic projection.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.settransformationparameters(camera_position_x, camera_position_y, camera_position_z, up_vector_x, up_vector_y, up_vector_z, focus_point_x, focus_point_y, focus_point_z)[source]¶
Method to set the camera position, the upward facing direction and the focus point of the shown volume.
Parameters:
- camera_position_x :
x component of the camera position in world coordinates
- camera_position_y :
y component of the camera position in world coordinates
- camera_position_z :
z component of the camera position in world coordinates
- up_vector_x :
x component of the up vector
- up_vector_y :
y component of the up vector
- up_vector_z :
z component of the up vector
- focus_point_x :
x component of focus-point inside volume
- focus_point_y :
y component of focus-point inside volume
- focus_point_z :
z component of focus-point inside volume
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.inqtransformationparameters()[source]¶
Return the camera position, up vector and focus point.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.camerainteraction(start_mouse_position_x, start_mouse_position_y, end_mouse_position_x, end_mouse_position_y)[source]¶
Interface for interaction with the rotation of the model. For this a virtual Arcball is used.
Parameters:
- start_mouse_position_x :
x component of the start mouse position
- start_mouse_position_y :
y component of the start mouse position
- end_mouse_position_x :
x component of the end mouse position
- end_mouse_position_y :
y component of the end mouse position
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.setwindow3d(x_min, x_max, y_min, y_max, z_min, z_max)[source]¶
Set the three dimensional window. Only used for perspective and orthographic projection.
Parameters:
- xmin :
min x-value
- xmax :
max x-value
- ymin :
min y-value
- ymax :
max y-value
- zmin :
min z-value
- zmax :
max z-value
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.inqwindow3d()[source]¶
Return the three dimensional window.
This function requires GR runtime version 0.46.0.post76 or higher.
- gr.setscalefactors3d(x_axis_scale, y_axis_scale, z_axis_scale)[source]¶
Set the scaling factor for each axis.
The scaling factors must not be zero.
Parameters:
- x_axis_scale :
x axis scaling factor
- y_axis_scale :
y axis scaling factor
- z_axis_scale :
z axis scaling factor
This function requires GR runtime version 0.48 or higher.
Control Functions¶
- gr.beginprint(pathname)[source]¶
Open and activate a print device.
Parameters:
- pathname :
Filename for the print device.
beginprint opens an additional graphics output device. The device type is obtained from the given file extension. 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
- gr.beginprintext(pathname, mode, fmt, orientation)[source]¶
Open and activate a print device with the given layout attributes.
Parameters:
- pathname :
Filename for the print device.
- mode :
Output mode (Color, GrayScale)
- fmt :
Output format (see table below)
- orientation :
Page orientation (Landscape, Portait)
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
- gr.begingraphics(path)[source]¶
Open a file for graphics output.
Parameters:
- path :
Filename for the graphics file.
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.
- gr.openws(workstation_id, connection, workstation_type)[source]¶
Open a graphical workstation.
Parameters:
- workstation_id :
A workstation identifier.
- connection :
A connection identifier.
- workstation_type :
The desired workstation type.
Available workstation types:
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
- gr.closews(workstation_id)[source]¶
Close the specified workstation.
Parameters:
- workstation_id :
A workstation identifier.
- gr.activatews(workstation_id)[source]¶
Activate the specified workstation.
Parameters:
- workstation_id :
A workstation identifier.