Module `Oplot.Plt`

Main Oplot functions

This module contains all functions for defining and rendering plots.

type plot_device = | X11 | GL | FIG
type view = Points.point * Points.point
type view3 = Points.point3 * Points.point3
type points = Points.point list
type axis
type image
type latex
type text
type imatrix = int array array
type fmatrix = float array array
type grid = fmatrix * view3 * bool
type surf3d = fmatrix * fmatrix * fmatrix * view3 * bool
type curve3d = Points.point3 list * view3
type move3d
type gllist
type color = { r : float; g : float; b : float; }

val black : color
val white : color
val red : color
val green : color
val blue : color
val yellow : color
val cyan : color
val magenta : color

type align = | CENTER | LEFT | RIGHT

Defining plot objects

'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 GL device. | 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) Pervasives.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.

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

3D objects

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

Other objects

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.

Displaying the plot objects

Various devices can be used to render the plots.

type user_device

val display : ?⁠dev:user_device → ?⁠fscreen:bool → ?⁠output:string → plot_object list → unit: Initialize the graphics device and display the plot objects

Available devices

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

Rendering parameters

val resize_window : int → int → unit
val get_gl_scale : unit → float: 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 set_gl_scale : float → unit
val quit : ?⁠dev:plot_device → unit → unit: Close the current rendering window and clear the temporary directory

val get_tmp_dir : unit → string

Drawing specific objects

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 elapsed : unit → int: Time elapsed from the openning of the opengl window

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.

val copy_back_buffer : unit → unit: Copy backbuffer to front buffer. If I use this intensively I can really hear my graphics card...

`\|` `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 `GL` device.
`\|` `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) Pervasives.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.