Simple graphics

rect(xmin, ymin, w, h, action)

Create a rectangle with one corner at (xmin/ymin) with width w and height h and then do an action.

See box() for more ways to do similar things, such as supplying two opposite corners, placing by centerpoint and dimensions.

rect(cornerpoint, w, h, action;
    vertices=false)

Create a rectangle with one corner at cornerpoint with width w and height h and do an action.

Use vertices=true to return an array of the four corner points: bottom left, top left, top right, bottom right.

box(cornerpoint1, cornerpoint2, action=:none;
    vertices=false)

Create a box (rectangle) between two points and do an action.

Use vertices=true to return an array of the four corner points: bottom left, top left, top right, bottom right.

box(points::Array, action=:none)

Create a box/rectangle using the first two points of an array of Points to defined opposite corners.

Use vertices=true to return an array of the four corner points: bottom left, top left, top right, bottom right.

box(pt::Point, width, height, action=:none; vertices=false)

Create a box/rectangle centered at point pt with width and height. Use vertices=true to return an array of the four corner points rather than draw the box.

box(x, y, width, height, action=:none)

Create a box/rectangle centered at point x/y with width and height.

box(pt, width, height, cornerradius, action=:none)

Draw a box/rectangle centered at point pt with width and height and round each corner by cornerradius.

box(bbox::BoundingBox, :action;
        vertices=false)

Make a box using the bounds in bbox.

Use vertices=true to return an array of the four corner points: bottom left, top left, top right, bottom right.

box(tiles::Tiler, n::T where T <: Integer, action::Symbol=:none;
    vertices=false)

Draw a box in tile n of tiles tiles.

box(t::Table, r::T, c::T, action::Symbol=:none) where T <: Integer

Draw a box in table t at row r and column c.

box(t::Table, cellnumber::Int, action::Symbol=:none; vertices=false)

Draw box cellnumber in table t.

box(tile::BoxmapTile, action::Symbol=:none; vertices=false)

Use a Boxmaptile to make or draw a rectangular box. Use vertices=true to obtain the coordinates.

Create boxmaps using boxmap().

circle(x, y, r, action=:none)

Make a circle of radius r centered at x/y.

action is one of the actions applied by do_action, defaulting to :none. You can also use ellipse() to draw circles and place them by their centerpoint.

circle(pt, r, action=:none)

Make a circle centered at pt.

circle(pt1::Point, pt2::Point, action=:none)

Make a circle that passes through two points that define the diameter:

circle(pt1::Point, pt2::Point, pt3::Point, action=:none)

Make a circle that passes through three points.

center3pts(a::Point, b::Point, c::Point)

Find the radius and center point for three points lying on a circle.

returns (centerpoint, radius) of a circle.

If there's no such circle, the function returns (Point(0, 0), 0).

ellipse(xc, yc, w, h, action=:none)

Make an ellipse, centered at xc/yc, fitting in a box of width w and height h.

ellipse(cpt, w, h, action=:none)

Make an ellipse, centered at point c, with width w, and height h.

ellipse(focus1::Point, focus2::Point, k, action=:none;
        stepvalue=pi/100,
        vertices=false,
        reversepath=false)

Build a polygon approximation to an ellipse, given two points and a distance, k, which is the sum of the distances to the focii of any points on the ellipse (or the shortest length of string required to go from one focus to the perimeter and on to the other focus).

ellipse(focus1::Point, focus2::Point, pt::Point, action=:none;
        stepvalue=pi/100,
        vertices=false,
        reversepath=false)

Build a polygon approximation to an ellipse, given two points and a point somewhere on the ellipse.

ellipseinquad(qgon, action=:none)

Calculate a Bézier-based ellipse that fits inside the quadrilateral qgon, an array of with at least four Points, then apply action.

Returns ellipsecenter, ellipsesemimajor, ellipsesemiminor, ellipseangle:

ellipsecenter the ellipse center

ellipsesemimajor ellipse semimajor axis

ellipsesemiminor ellipse semiminor axis

ellipseangle ellipse rotation

The function returns O, 0, 0, 0 if a suitable ellipse can't be found. (The qgon is probably not a convex polygon.)

References

http://faculty.mae.carleton.ca/John_Hayes/Papers/InscribingEllipse.pdf

circlepath(center::Point, radius, action=:none;
    reversepath=false,
    kappa = 0.5522847498307936)

Draw a circle using Bézier curves.

The magic value, kappa, is 4.0 * (sqrt(2.0) - 1.0) / 3.0.

pointcircletangent(point::Point, circlecenter::Point, circleradius)

Find the two points on a circle that lie on tangent lines passing through an external point.

If both points are O, the external point is inside the circle, and the result is (O, O).

circletangent2circles(radius, circle1center::Point, circle1radius, circle2center::Point, circle2radius)

Find the centers of up to two circles of radius radius that are tangent to the two circles defined by circle1... and circle2.... These two circles can overlap, but one can't be inside the other.

• (0, O, O) - no such circles exist

• (1, pt1, O) - 1 circle exists, centered at pt1

• (2, pt1, pt2) - 2 circles exist, with centers at pt1 and pt2

(The O are just dummy points so that three values are always returned.)

circlepointtangent(through::Point, radius, targetcenter::Point, targetradius)

Find the centers of up to two circles of radius radius that pass through point through and are tangential to a circle that has radius targetradius and center targetcenter.

This function returns a tuple:

• (0, O, O) - no circles exist

• (1, pt1, O) - 1 circle exists, centered at pt1

• (2, pt1, pt2) - 2 circles exist, with centers at pt1 and pt2

(The O are just dummy points so that three values are always returned.)

circlecircleinnertangents(circle1center::Point, circle1radius, circle2center::Point, circle2radius)

Find the inner tangents of two circles. These are tangent lines that cross as they skim past one circle and touch the other.

Returns the four points: tangentpoint1 on circle 1, tangentpoint1 on circle2, tangentpoint2 on circle 1, tangentpoint2 on circle2.

Returns (O, O, O, O) if inner tangents can't be found (eg when the circles overlap).

Use circlecircleoutertangents() to find the outer tangents.

circlecircleoutertangents(cpt1::Point, r1, cpt2::Point, r2)

Return four points, p1, p2,p3,p4, where a line throughp1andp2, and a line throughp3andp4, form the outer tangents to the circles defined bycpt1/r1andcpt2/r2`.

Returns four identical points (O) if one of the circles lies inside the other.

move(pt)

Move to a point.

rmove(pt)

Move relative to current position by the pt's x and y:

newpath()

Create a new path. This is Cairo's new_path() function.

newsubpath()

Add a new subpath to the current path. This is Cairo's new_sub_path() function. It can be used for example to make holes in shapes.

closepath()

Close the current path. This is Cairo's close_path() function.

currentpoint()

Return the current point.

hascurrentpoint()

Return true if there is a current point. Obtain the current point with currentpoint().

line(pt)

Draw a line from the current position to the pt.

line(pt1::Point, pt2::Point, action=:none)

Make a line between two points, pt1 and pt2 and do an action.

rline(pt)

Draw a line relative to the current position to the pt.

rule(pos, theta;
    boundingbox=BoundingBox(),
    vertices=false)

Draw a straight line through pos at an angle theta from the x axis.

By default, the line spans the entire drawing, but you can supply a BoundingBox to change the extent of the line.

rule(O)       # draws an x axis
rule(O, pi/2) # draws a  y axis

The function:

rule(O, pi/2, boundingbox=BoundingBox()/2)

draws a line that spans a bounding box half the width and height of the drawing, and returns a Set of end points. If you just want the vertices and don't want to draw anything, use vertices=true.

arrow(startpoint::Point, endpoint::Point;
    linewidth = 1.0,
    arrowheadlength = 10,
    arrowheadangle = pi/8,
    decoration = 0.5,
    decorate = () -> ())

Draw a line between two points and add an arrowhead at the end. The arrowhead length will be the length of the side of the arrow's head, and the arrowhead angle is the angle between the sloping side of the arrowhead and the arrow's shaft.

Arrows don't use the current linewidth setting (setline()), and defaults to 1, but you can specify another value. It doesn't need stroking/filling, the shaft is stroked and the head filled with the current color.

The decorate keyword argument accepts a function that can execute code at locations on the arrow's shaft. The inherited graphic environment is centered at each point on the curve between 0 and 1 given by scalar or vector decoration, and the x-axis is aligned with the direction of the curve at that point.

arrow(centerpos::Point, radius, startangle, endangle;
    linewidth = 1.0,
    arrowheadlength = 10,
    arrowheadangle = pi/8,
    decoration = 0.5,
    decorate = () -> ())

Draw a curved arrow, an arc centered at centerpos starting at startangle and ending at endangle with an arrowhead at the end. Angles are measured clockwise from the positive x-axis.

Arrows don't use the current linewidth setting (setline()); you can specify the linewidth.

The decorate keyword argument accepts a function that can execute code at locations on the arrow's shaft. The inherited graphic environment is centered at points on the curve between 0 and 1 given by scalar or vector decoration, and the x-axis is aligned with the direction of the curve at that point.

arrow(start::Point, C1::Point, C2::Point, finish::Point, action=:stroke;
    linewidth=1.0,
    arrowheadlength=10,
    arrowheadangle=pi/8,
    startarrow=false,
    finisharrow=true,
    decoration = 0.5,
    decorate = () -> ()))

Draw a Bezier curved arrow, from start to finish, with control points C1 and C2. Arrow heads can be added/hidden by changing startarrow and finisharrow options.

The decorate keyword argument accepts a function that can execute code at locations on the arrow's shaft. The inherited graphic environment is centered at each point on the curve given by scalar or vector decoration, and the x-axis is aligned with the direction of the curve at that point (TODO - more or less - is it actually correct?).

arrow(start::Point, finish::Point, height::Vector, action=:stroke;
    keyword arguments...)

Draw a Bézier arrow between start and finish, with control points defined to fit in an imaginary box defined by the two supplied height values (see bezierfrompoints()). If the height values are different signs, the arrow will change direction on its way.

Keyword arguments are the same as arrow(pt1, pt2, pt3, pt4).

Example

arrow(pts[1], pts[end], [15, 15],
    decoration = 0.5,
    decorate = () -> text(string(pts[1])))

arc(xc, yc, radius, angle1, angle2, action=:none)

Add an arc to the current path from angle1 to angle2 going clockwise, centered at xc, yc.

Angles are defined relative to the x-axis, positive clockwise.

arc(centerpoint::Point, radius, angle1, angle2, action=:none)

Add an arc to the current path from angle1 to angle2 going clockwise, centered at centerpoint.

  arc2r(c1::Point, p2::Point, p3::Point, action=:none)

Add a circular arc centered at c1 that starts at p2 and ends at p3, going clockwise, to the current path.

c1-p2 really determines the radius. If p3 doesn't lie on the circular path, it will be used only as an indication of the arc's length, rather than its position.

carc(xc, yc, radius, angle1, angle2, action=:none)

Add an arc to the current path from angle1 to angle2 going counterclockwise, centered at xc/yc.

Angles are defined relative to the x-axis, positive clockwise.

carc(centerpoint::Point, radius, angle1, angle2, action=:none)

Add an arc centered at centerpoint to the current path from angle1 to angle2, going counterclockwise.

carc2r(c1::Point, p2::Point, p3::Point, action=:none)

Add a circular arc centered at c1 that starts at p2 and ends at p3, going counterclockwise, to the current path.

c1-p2 really determines the radius. If p3 doesn't lie on the circular path, it will be used only as an indication of the arc's length, rather than its position.

arc2sagitta(p1::Point, p2::Point, s, action=:none)

Make a clockwise arc starting at p1 and ending at p2 that reaches a height of s, the sagitta, at the middle. Might append to current path...

Return tuple of the center point and the radius of the arc.

carc2sagitta(p1::Point, p2::Point, s, action=:none)

Make a counterclockwise arc starting at p1 and ending at p2 that reaches a height of s, the sagitta, at the middle. Might append to current path...

Return tuple of center point and radius of arc.

curve(x1, y1, x2, y2, x3, y3)
curve(p1, p2, p3)

Add a Bézier curve.

The spline starts at the current position, finishing at x3/y3 (p3), following two control points x1/y1 (p1) and x2/y2 (p2).

sector(centerpoint::Point, innerradius, outerradius, startangle, endangle, action:none)

Draw an annular sector centered at centerpoint.

sector(innerradius::Real, outerradius::Real, startangle::Real, endangle::Real,
   action::Symbol=:none)

Draw an annular sector centered at the origin.

sector(centerpoint::Point, innerradius, outerradius, startangle, endangle,
    cornerradius, action:none)

Draw an annular sector with rounded corners, basically a bent sausage shape, centered at centerpoint.

TODO: The results aren't 100% accurate at the moment. There are small discontinuities where the curves join.

The cornerradius is reduced from the supplied value if neceesary to prevent overshoots.

sector(innerradius::Real, outerradius::Real, startangle::Real, endangle::Real,
   cornerradius::Real, action::Symbol=:none)

Draw an annular sector with rounded corners, centered at the current origin.

pie(x, y, radius, startangle, endangle, action=:none)

Draw a pie shape centered at x/y. Angles start at the positive x-axis and are measured clockwise.

pie(centerpoint, radius, startangle, endangle, action=:none)

Draw a pie shape centered at centerpoint.

Angles start at the positive x-axis and are measured clockwise.

pie(radius, startangle, endangle, action=:none)

Draw a pie shape centered at the origin

spiral(a, b, action::Symbol=:none;
                 stepby = 0.01,
                 period = 4pi,
                 vertices = false,
                 log=false)

Make a spiral. The two primary parameters a and b determine the start radius, and the tightness.

For linear spirals (log=false), b values are:

lituus: -2

hyperbolic spiral: -1

Archimedes' spiral: 1

Fermat's spiral: 2

For logarithmic spirals (log=true):

golden spiral: b = ln(phi)/ (pi/2) (about 0.30)

Values of b around 0.1 produce tighter, staircase-like spirals.

squircle(center::Point, hradius, vradius, action=:none;
    rt = 0.5, stepby = pi/40, vertices=false)

Make a squircle or superellipse (basically a rectangle with rounded corners). Specify the center position, horizontal radius (distance from center to a side), and vertical radius (distance from center to top or bottom):

The root (rt) option defaults to 0.5, and gives an intermediate shape. Values less than 0.5 make the shape more rectangular. Values above make the shape more round. The horizontal and vertical radii can be different.

star(xcenter, ycenter, radius, npoints=5, ratio=0.5, orientation=0, action=:none;
    vertices = false,
    reversepath=false)

Make a star. ratio specifies the height of the smaller radius of the star relative to the larger.

Use vertices=true to return the vertices of a star instead of drawing it.

star(center, radius, npoints=5, ratio=0.5, orientation=0, action=:none;
    vertices = false, reversepath=false)

Draw a star centered at a position:

polycross(pt::Point, radius, npoints::Int, ratio=0.5, orientation=0.0, action=:none;
    splay       = 0.5,
    vertices    = false,
    reversepath = false)

Make a cross-shaped polygon with npoints arms to fit inside a circle of radius radius centered at pt.

ratio specifies the ratio of the two sides of each arm. splay makes the arms ... splayed.

Use vertices=true to return the vertices of the shape instead of drawing it.

(Adapted from Compose.jl.xgon()))