Reference

Vec2(x, y) -> v

Create a Cartesian representation v of a vector (or point) in two dimensions.

Point(x, y) -> p

Create a Cartesian representation p of a point in two dimensions. Point is an alias of Vec2.

BoundingBox(xmin, xmax, ymin, ymax) -> bb

Create a representation bb of a rectangular region, specifying the coordinates of the horizontal (x) and vertical (y) edges.

aspect_ratio(bb::BoundingBox) -> r

Compute the ratio r of the height and width of bb.

Example

julia> bb = BoundingBox(Point(0, 0), Point(1920, 1080)); # landscape

julia> aspect_ratio(bb)
0.5625

julia> rationalize(ans)
9//16

center(obj) -> p::Point

Compute the center coordinate of obj.

deform(bb::BoundingBox, Δl, Δr, Δt, Δb) -> bbnew

Add Δl (left), Δr (right), Δt (top), and Δb (bottom) to the edges of a BoundingBox. The sign of each value follows the positive direction of the axis. The "top" and "bottom" are representations when the y-axis is directed downward.

Example

julia> bb = BoundingBox(Point(1, 1), Point(10, 10));

julia> bbnew = deform(bb, 0.5, -1.0, -0.25, 1.0);

julia> xrange(bbnew), yrange(bbnew)
((1.5, 9.0), (0.75, 11.0))

diagonal(obj) -> diag

Get the diagonal length of obj. The fallback implementation of this function returns the diagonal length of the bounding box of obj.

isinside(bb::BoundingBox, p::Point) -> tf::Bool
isinside(bb::BoundingBox, x, y) -> tf::Bool

Determine whether the point lies within bb.

shift(bb::BoundingBox, Δx, Δy) -> bbnew

Shift center by (Δx, Δy), keeping width & height fixed.

height(obj) -> h

Get the vertical length of obj.

width(obj) -> w

Get the horizontal length of obj.

xmin(obj) -> xmin

Get the minimum x coordinate of the bounding box of obj.

xmax(obj) -> xmax

Get the maximum x coordinate of the bounding box of obj.

ymin(obj) -> ymin

Get the minimum x coordinate of the bounding box of obj.

ymax(obj) -> ymax

Get the maximum y coordinate of the bounding box of obj.

xrange(obj) -> (xmin, xmax)

Get the horizontal range of the bounding box that minimally contains obj.

yrange(obj) -> (ymin, ymax)

Get the vertical range of the bounding box that minimally contains obj.

GraphicDevice

An abstract graphics output device; can create GraphicsContexts.

GraphicsContext

An abstract object that can actually be drawn to.

creategc(gd::GraphicsDevice) -> gc::GraphicContext

Create a new GraphicContext.

getgc(obj) -> gc::GraphicContext

Get a GraphicsContext from something that might be drawable.

set_coordinates(gc::GraphicsContext, device::BoundingBox, user::BoundingBox)
set_coordinates(gc::GraphicsContext, user::BoundingBox)

Set the device->user coordinate transformation of c so that device, expressed in "device coordinates" (pixels), is equivalent to user as expressed in "user coordinates". If device is omitted, it defaults to the full span of gc, BoundingBox(0, width(gc), 0, height(gc)).

reset_transform(gc::GraphicsContext)

Reset the current transformation.

rotate(p::Vec2, angle::Real, o::Vec2 = Vec2(0, 0)) -> pnew::Vec2

Rotate p around o by angle (in radians).

Example

julia> rotate(Vec2(2, 1), 0.5π, Vec2(1, 1))
Vec2(1.0, 2.0)

rotate(bb::BoundingBox, angle::Real, o::Point) -> bbnew

Rotate bb around o by angle (in radians), returning the BoundingBox that encloses the vertices of the rotated box.

rotate(gc::GraphicsContext, angle)

Rotate the user-space axes by angle (in radians). The rotation takes places after any existing transformation.

See also: rotate(p::Vec2, angle::Real, o::Vec2).

scale(gc::GraphicsContext, sx, sy)

Scale the user-space x-axis and y-axis by sx and sy respectively. The scaling takes places after any existing transformation.

translate(gc::GraphicsContext, Δx, Δy)

Translate the user-space origin by (Δx, Δy). The translation takes places after any existing transformation.

user_to_device!(gc::GraphicsContext, c::Vector{Float64})

Transform a coordinate c from the user space to the device space.

See also: user_to_device, device_to_user!

device_to_user!(gc::GraphicsContext, c::Vector{Float64})

Transform a coordinate c from the device space to the user space.

See also: device_to_user, user_to_device!

user_to_device_distance!(gc::GraphicsContext, d::Vector{Float64})

Transform a distance vector d from the user space to the device space. This function is similar to the device_to_user! except that the translation components will be cancelled.

device_to_user_distance!(gc::GraphicsContext, d::Vector{Float64})

Transform a distance vector d from the device space to the user space. This function is similar to the user_to_device! except that the translation components will be cancelled.

user_to_device(gc::GraphicsContext, x, y) -> (xd, yd)

Transform a user space coordinate (x, y) to the device space coordinate (xd, yd).

See also: user_to_device!, device_to_user

device_to_user(gc::GraphicsContext, x, y) -> (xu, yu)

Transform a device space coordinate (x, y) to the user space coordinate (xu, yu).

See also: device_to_user!, user_to_device

set_line_width(gc::GraphicsContext, w)

Set the current line width (in device-depended units). The actual width and aspect-ratio on the screen may be affected by the transformation.

set_dash(gc::GraphicsContext, dashes::Vector{Float64}, offset)

Set the dash pattern. The dashes is a Vector of positive lengths. The odd-numbered elements represent the length of the "on" state, and the even-numbered elements represent the length of the "off" (blank) state. The offset specifies an offset at which the stroke begins. If dashes is empty, dashing is disabled.

set_source(gc::GraphicsContext, src)

Set the source pattern to src. If the src is a Color, it is used as the source color.

set_source_rgb(gc::GraphicsContext, r, g, b)

Set the source pattern to an opaque color RGB(r, g, b). The color components are in the range [0, 1], not [0, 255].

See also: set_source_rgba.

set_source_rgba(gc::GraphicsContext, r, g, b, a)

Set the source pattern to a transparent color RGBA(r, g, b, a). The color and alpha components are in the range [0, 1], not [0, 255].

See also: set_source_rgb.

save(gc::GraphicsContext)

Save the copy of current context gc. The context is saved onto an internal stack, for example.

See also: restore

restore(gc::GraphicsContext)

Restore the context saved by a preceding save. The state at the time of the call is overwritten with the restored context, and the restored context is removed from an internal stack, for example.

clip(gc::GraphicsContext)

Set a new clipping region based on the current path and fill within the context.

See also: reset_clip, clip_preserve.

clip_preserve(gc::GraphicsContext)

Set a new clipping region based on the current path and fill within the context. Unlike the clip function, this function preserves the path within the context.

reset_clip(gc::GraphicsContext)

Remove the clipping region set by the clip or clip_preserve function.

inner_canvas(gc::GraphicsContext, device::BoundingBox, user::BoundingBox)
inner_canvas(gc::GraphicsContext, x, y, w, h, l, r, t, b)

Create a rectangular drawing area inside device (represented in device-coordinates), giving it user-coordinates user. Any drawing that occurs outside this box is clipped.

x, y, w, and h are an alternative parametrization of device, and l, r, t, b parametrize user.

See also: set_coordinates.

move_to(gc::GraphicsContext, x, y)

Begin a new sub-path. The current point will be moved to (x, y).

See also: rel_move_to.

line_to(gc::GraphicsContext, x, y)

Add a line to the current path from the current point to the position (x, y). The current point will be moved to (x, y).

See also: rel_line_to.

rel_line_to(gc::GraphicsContext, Δx, Δy)

Add a line to the current path from the current point of (x, y) to the position (x + Δx, y + Δy). The current point will be moved to (x + Δx, y + Δy).

See also: line_to.

rel_move_to(gc::GraphicsContext, Δx, Δy)

Begin a new sub-path. The current point will be moved to (x + Δx, y + Δy), where (x, y) is the previous current point.

See also: move_to.

new_path(gc::GraphicsContext)

Clear the current path.

new_sub_path(gc::GraphicsContext)

Begin a new sub-path. The current point will be cleared.

See also: move_to.

close_path(gc::GraphicsContext)

Add a line to the current path from the current point to the beginning of the current sub-path and closes the sub-path. The current point will be changed to the joined point.

There is a difference between closing a subpath and drawing a line to the equivalent coordinate. This difference might be visualized as a difference in drawing stroke endpoints.

arc(gc::GraphicsContext, xc, yc, radius, angle1, angle2)

Add a circular arc with the specified radius to the current path. The arc is centered at (xc, yc), begins at angle1 and ends at angle2. The angle1 and angle2 are in radians. The arc will be drawn in the direction of increasing angles.

rectangle(gc::GraphicsContext, x, y, width, height)
rectangle(gc::GraphicsContext, user::BoundingBox)

Add a sub-path rectangle to the current path. The x and y specify the (typically the upper left) corner coordinate of the rectangle, and the width and height specify the size.

You can also specify the position and size by a BoundingBox in user-space coordinate.

circle(gc::GraphicsContext, x, y, r)

Add a sub-path circle to the current path. The x and y specify the center coordinate of the circle, and the r specifies the radius.

polygon(gc::GraphicsContext, verts::Matrix, idx::Vector)

Add a closed sub-path polygon with the given vertices. The verts is a collection of vertex coordinates in the following matrix form:

[x1 x2 x3 ... xn;
 y1 y2 y3 ... yn]

The idx is a vector of vertex indices, i.e. the matrix column numbers.

polygon(gc::GraphicsContext, points::AbstractVector)

Add a closed sub-path polygon with the given vertices to .

fill(gc::GraphicsContext)

Fill the current path according to the current fill rule. The current path will be cleared from the context.

See also: fill_preserve.

fill_preserve(gc::GraphicsContext)

Fill the current path according to the current fill rule. Unlike the fill function, this function preserves the current path within the context.

paint(gc::GraphicsContext)

Paint the current source everywhere within the current clipping region.

stroke(gc::GraphicsContext)

Stroke the current path according to the current stroke style. The current path will be cleared from the context.

See also: stroke_preserve.

stroke_preserve(gc::GraphicsContext)

Stroke the current path according to the current stroke style. Unlike the stroke function, this function preserves the current path within the context.

stroke_transformed(gc::GraphicsContext)

Stroke the current path according to the current stroke style and the current transformation.

See also: stroke.

stroke_transformed_preserve(gc::GraphicsContext)

Stroke the current path according to the current stroke style and the current transformation. Unlike the stroke_transformed function, this function preserves the current path within the context.

See also: stroke_preserve.