Oplot.Plt
Main Oplot functions
This module contains all functions for defining and rendering plots.
type view = Points.point * Points.point
type view3 = Points.point3 * Points.point3
type points = Points.point list
type curve3d = Points.point3 list * view3
val black : color
val white : color
val red : color
val green : color
val blue : color
val yellow : color
val cyan : color
val magenta : color
'Defining' means computing the coordinates of the points and lines to display, but not actually displaying them. We call a "sheet" a list of objects to be displayed.
type plot_object =
| Points of points | (* A list of points. *) |
| Lines of points list | (* The points of each sublist are joined by a line segment. *) |
| Poly of points | (* Closed polygonal line. *) |
| View of view option | (* Indicate the x-y range to display. *) |
| Axis of axis | (* Axis with divisions. *) |
| Color of color | (* Indicate the color to draw subsequent objects. *) |
| Text of text | (* Position a text at some (x,y) coordinate. *) |
| Matrix of imatrix | (* Checkboard-like matrix view with 0-255 greyscale. *) |
| Grid of grid * gllist | (* 3D mountain-like representation of a matrix. *) |
| Surf3d of surf3d * gllist | (* 3D parametric surface. *) |
| Curve3d of curve3d * gllist | (* 3D points joined by line segments. *) |
| Move3d of move3d | (* Animate the 3D object by a uniform rotation. *) |
| Pause of int | (* Display the current state of the sheet, and wait before displaying next object, but don't stop animation in the opengl window. This only works for interactive displays using the |
| Freeze of int | (* Display the current state of the sheet and suspend all display for the given time. *) |
| Clear of color | (* Clear graphics. *) |
| Adapt of (view option * plot_object option) Stdlib.ref
* view option ->
plot_object | (* Any object that needs to adapt itself to the current View. *) |
| User of view -> plot_device -> unit | (* Execute any user-defined program. *) |
| Sheet of plot_object list | (* Group plot objects. *) |
Helper functions for creating 2D plot objects
val point : (float * float) -> Points.point
A single point (x,y).
val axis : float -> float -> plot_object
axis x0 y0
creates an Axis
object with two axis crossing at the point (x0
,y0
).
val parametric_plot :
( float -> float ) ->
( float -> float ) ->
?pas:float ->
?adapt:bool ->
float ->
float ->
plot_object
parametric_plot fx fy t0 t1
computes a parametric curve given by the points (fx
(t), fy
(t)), for t varyingn from t0
to t1
. If adapt
is true, the step will adapt to the arc-length of the curve.
val point_plot_f :
( float -> float ) ->
?pas:float ->
float ->
float ->
plot_object
point_plot_f f x0 x1
computes a subset of the graph of the function f
obtained by isolated points with a fixed horizontal step.
val line_plot_f :
( float -> float ) ->
?pas:float ->
float ->
float ->
plot_object
Similar to point_plot_f
but the points are joined by line segments.
val plot : ( float -> float ) -> ?pas:float -> float -> float -> plot_object
Alias for line_plot_f
.
val adapt_plot :
( float -> float ) ->
?pas:float ->
float ->
float ->
plot_object
Similar to line_plot_f
, but the plot will be dynamically cropped to the current view
object. It returns an Adapt
object.
val anim_plot :
( float -> float -> float ) ->
?pas:float ->
?t0:float ->
?t1:float ->
float ->
float ->
plot_object
If f
is a function two parameters t
and x
, then anim_plot f x0 x1
will generate an animation of the graph of the functions f t
for t
evolving with real time. The resulting object is of type User
.
val dot_plot :
?dot:( float -> float -> plot_object ) ->
?view:plot_object ->
(float * float) list ->
plot_object list
dot_plot ~dot list
draws a dot at each position (x,y)
in the given list
. Each dot is plotted using the dot
function. By default, if ~dot
is not specified, a single pixel is drawn. Another possibility is to use thediamond
function.
val diamond : ?size:float -> float -> float -> plot_object
Draw a small diamond (lozange) at the given x y
position.
val box : float -> float -> float -> float -> plot_object
box x0 y0 x1 y1
draws a filled box given by the diagonal points x0,y0
and x1,y1
.
val text : string -> ?size:int -> ?align:align -> float -> float -> plot_object
text s x y
draws the string s
at the position (x
,y
).
val move_text : text -> Points.point -> unit
Move text at position given by point
.
val latex :
string ->
?size:int ->
?align:align ->
float ->
float ->
plot_object
Similar to text
but the rendered text is the result of LaTeX compilation of the given string.
val view : float -> float -> float -> float -> plot_object
view x0 y0 x1 y1
creates a View
object indicating the bounding box for subsequent drawings.
Helper functions for creating 3D plot objects
val point3 : (float * float * float) -> Points.point3
A single 3D point (x,y,z).
val surf3d_plot :
( float -> float -> float ) ->
( float -> float -> float ) ->
( float -> float -> float ) ->
?width:int ->
?height:int ->
?wire:bool ->
float ->
float ->
float ->
float ->
plot_object
surf3d_plot fx fy fz u0 v0 u1 v1
computes the parametric surface spanned by the map (u,v)->(fx(u,v), fy(u,v), fz(u,v)) when (u,v) varies in the range [u0,u1] ✕ [v0,v1]
.
val grid_plot :
( float -> float -> float ) ->
?wire:bool ->
?width:int ->
?height:int ->
float ->
float ->
float ->
float ->
plot_object
grid_plot f x0 y0 x1 y1
computes the graph of the function f
of two variables x y, when (x,y) varies in the range [x0,x1] ✕ [y0,y1]
.
val color : float -> float -> float -> plot_object
Specifies the RGB color for subsequent drawings.
val freeze : int -> plot_object
freeze t
creates a Freeze
for t
ms.
val pause : int -> plot_object
pause t
creates a Pause
for t
ms.
val rotate : float -> float -> float -> float -> float -> plot_object
rotate x y z theta t
rotates the 3D scene with angular velocity theta
(in radians) aroung the axis (x
,y
,z
), during time t
.
Various devices can be used to render the plots.
val display :
?dev:user_device ->
?fscreen:bool ->
?output:string ->
plot_object list ->
unit
Initialize the graphics device and display the plot objects
val x11 : user_device
Software rendering in a separate window
val gl : user_device
Hardware (opengl) rendering in a separate window. This is the default
val fig : user_device
Render to an xfig file
val xfig : user_device
Open in the xfig
program, if present
val eps : user_device
Render to an EPS (encapsulated postscript) file
val pdf : user_device
Render to a PDF (portable document format) file
val gv : user_device
Render to EPS and open with a postscript viewer like gv
val bmp : user_device
Render to a BMP image
val img : user_device
Open in an image viewer
The GL_SCALE is used to accomodate for HI-DPI screens. A "normal" screen of DPI about 110 should have GL_SCALE=1. A HI-DPI screen can typically have a scale of 2 or 2.5; on linux the GL_SCALE is detected at startup. It can be modified by the user.
val quit : ?dev:plot_device -> unit -> unit
Close the current rendering window and clear the temporary directory
These functions should not be used interactively, because they necessitate the graphics window to be already opened by display
; but they can be interesting when programming a User
object.
val set_color : ?dev:plot_device -> color -> unit
val object_plot :
?addcounter:bool ->
dev:plot_device ->
plot_object ->
view option ->
unit
Draw a single object, but not a Sheet. The device must have been initialized before.
If addcounter
is true (default) the object will be considered as a new element of the currently displayed sheet; otherwise, it will be considered as being part of the currently displayed object: this only affects the Pause
mechanism.
val user_flush : plot_device -> unit
Synchronize graphics output by swapping back and front buffers. Hence two consecutive calls will result in flicker. See copy_back_buffer
.