Colors and styles

sethue("black")
sethue(0.3, 0.7, 0.9)
setcolor(sethue("red")..., .2)

Set the color without changing opacity.

sethue() is like setcolor(), but we sometimes want to change the current color without changing alpha/opacity. Using sethue() rather than setcolor() doesn't change the current alpha opacity.

See also setcolor.

sethue(col::ColorTypes.Colorant)

Set the color without changing the current alpha/opacity:

sethue(0.3, 0.7, 0.9)

Set the color's r, g, b values. Use setcolor(r,g,b,a) to set transparent colors.

sethue((r, g, b))

Set the color to the tuple's values.

sethue((r, g, b, a))

Set the color to the tuple's values.

setcolor("gold")
setcolor("darkturquoise")

Set the current color to a named color. This use the definitions in Colors.jl to convert a string to RGBA eg setcolor("gold") or "green", "darkturquoise", "lavender", etc. The list is at Colors.color_names.

Use sethue() for changing colors without changing current opacity level.

sethue() and setcolor() return the three or four values that were used:

julia> setcolor(sethue("red")..., .8)

(1.0,0.0,0.0,0.8)

julia> sethue(setcolor("red")[1:3]...)

(1.0,0.0,0.0)

You can also do:

using Colors
sethue(colorant"red")

See also setcolor.

setcolor(r, g, b)
setcolor(r, g, b, alpha)
setcolor(color)
setcolor(col::ColorTypes.Colorant)
setcolor(sethue("red")..., .2)

Set the current color.

Examples:

setcolor(convert(Colors.HSV, Colors.RGB(0.5, 1, 1)))
setcolor(.2, .3, .4, .5)
setcolor(convert(Colors.HSV, Colors.RGB(0.5, 1, 1)))

for i in 1:15:360
   setcolor(convert(Colors.RGB, Colors.HSV(i, 1, 1)))
   ...
end

See also sethue.

setcolor((r, g, b))

Set the color to the tuple's values.

setcolor((r, g, b, a))

Set the color to the tuple's values.

setgray(n)
setgrey(n)

Set the color to a gray level of n, where n is between 0 and 1.

setopacity(alpha)

Set the current opacity to a value between 0 and 1. This modifies the alpha value of the current color.

randomhue()

Set a random hue, without changing the current alpha opacity.

randomcolor()

Set a random color. This may change the current alpha opacity too.

setblend(blend)

Start using the named blend for filling graphics.

This aligns the original coordinates of the blend definition with the current axes.

setline(n)

Set the line width.

setlinecap(s)

Set the line ends. s can be "butt" (the default), "square", or "round".

setlinejoin("miter")
setlinejoin("round")
setlinejoin("bevel")

Set the line join style, or how to render the junction of two lines when stroking.

setlinedash("dot")

Set the dash pattern to one of: "solid", "dotted", "dot", "dotdashed", "longdashed", "shortdashed", "dash", "dashed", "dotdotdashed", "dotdotdotdashed"

fillstroke()

Fill and stroke the current path.

strokepath()

Stroke the current path with the current line width, line join, line cap, and dash settings. The current path is then cleared.

fillpath()

Fill the current path according to the current settings. The current path is then cleared.

strokepreserve()

Stroke the current path with current line width, line join, line cap, and dash settings, but then keep the path current.

fillpreserve()

Fill the current path with current settings, but then keep the path current.

paint()

Paint the current clip region with the current settings.

do_action(action)

This is usually called by other graphics functions. Actions for graphics commands include :fill, :stroke, :clip, :fillstroke, :fillpreserve, :strokepreserve, :none, and :path.

blend(from::Point, to::Point)

Create an empty linear blend.

A blend is a specification of how one color changes into another. Linear blends are defined by two points: parallel lines through these points define the start and stop locations of the blend. The blend is defined relative to the current axes origin. This means that you should be aware of the current axes when you define blends, and when you use them.

To add colors, use addstop().

blend(centerpos1, rad1, centerpos2, rad2, color1, color2)

Create a radial blend.

Example:

redblue = blend(
    pos, 0,                   # first circle center and radius
    pos, tiles.tilewidth/2,   # second circle center and radius
    "red",
    "blue"
    )

blend(pt1::Point, pt2::Point, color1, color2)

Create a linear blend.

Example:

redblue = blend(pos, pos, "red", "blue")

blend(from::Point, startradius, to::Point, endradius)

Create an empty radial blend.

Radial blends are defined by two circles that define the start and stop locations. The first point is the center of the start circle, the first radius is the radius of the first circle.

A new blend is empty. To add colors, use addstop().

addstop(b::Blend, offset, col)
addstop(b::Blend, offset, (r, g, b, a))
addstop(b::Blend, offset, string)

Add a color stop to a blend. The offset specifies the location along the blend's 'control vector', which varies between 0 (beginning of the blend) and 1 (end of the blend). For linear blends, the control vector is from the start point to the end point. For radial blends, the control vector is from any point on the start circle, to the corresponding point on the end circle.

Examples:

blendredblue = blend(Point(0, 0), 0, Point(0, 0), 1)
addstop(blendredblue, 0, setcolor(sethue("red")..., .2))
addstop(blendredblue, 1, setcolor(sethue("blue")..., .2))
addstop(blendredblue, 0.5, sethue(randomhue()...))
addstop(blendredblue, 0.5, setcolor(randomcolor()...))

blendadjust(ablend, center::Point, xscale, yscale, rot=0)

Modify an existing blend by scaling, translating, and rotating it so that it will fill a shape properly even if the position of the shape is nowhere near the original location of the blend's definition.

For example, if your blend definition was this (notice the 1)

blendgoldmagenta = blend(
        Point(0, 0), 0,                   # first circle center and radius
        Point(0, 0), 1,                   # second circle center and radius
        "gold",
        "magenta"
        )

you can use it in a shape that's 100 units across and centered at pos, by calling this:

blendadjust(blendgoldmagenta, Point(pos.x, pos.y), 100, 100)

then use setblend():

setblend(blendgoldmagenta)

setmode(mode::String)

Set the compositing/blending mode. mode can be one of:

• "clear" Where the second object is drawn, the first is completely removed.
• "source" The second object is drawn as if nothing else were below.
• "over" The default mode: like two transparent slides overlapping.
• "in" The first object is removed completely, the second is only drawn where the first was.
• "out" The second object is drawn only where the first one wasn't.
• "atop" The first object is mostly intact, but mixes both objects in the overlapping area. The second object object is not drawn elsewhere.
• "dest" Discard the second object completely.
• "dest_over" Like "over" but draw second object below the first
• "dest_in" Keep the first object whereever the second one overlaps.
• "dest_out" The second object is used to reduce the visibility of the first where they overlap.
• "dest_atop" Like "over" but draw second object below the first.
• "xor" XOR where the objects overlap
• "add" Add the overlapping areas together
• "saturate" Increase Saturation where objects overlap
• "multiply" Multiply where objects overlap
• "screen" Input colors are complemented and multiplied, the product is complemented again. The result is at least as light as the lighter of the input colors.
• "overlay" Multiplies or screens colors, depending on the lightness of the destination color.
• "darken" Selects the darker of the color values in each component.
• "lighten" Selects the lighter of the color values in each component.

See the Cairo documentation for details.

getmode()

Return the current compositing/blending mode as a string.

mesh(bezierpath::BezierPath,
     colors=AbstractArray{ColorTypes.Colorant, 1})

Create a mesh. The first three or four elements of the supplied bezierpath define the three or four sides of the mesh shape.

The colors array define the color of each corner point. Colors are reused if necessary. At least one color should be supplied.

Use setmesh() to select the mesh, which will be used to fill shapes.

Example

@svg begin
    bp = makebezierpath(ngon(O, 50, 4, 0, vertices=true))
    mesh1 = mesh(bp, [
        "red",
        Colors.RGB(0, 1, 0),
        Colors.RGB(0, 1, 1),
        Colors.RGB(1, 0, 1)
        ])
    setmesh(mesh1)
    box(O, 500, 500, :fill)
end

mesh(points::AbstractArray{Point},
     colors=AbstractArray{ColorTypes.Colorant, 1})

Create a mesh.

Create a mesh. The first three or four sides of the supplied points polygon define the three or four sides of the mesh shape.

The colors array define the color of each corner point. Colors are reused if necessary. At least one color should be supplied.

Example

@svg begin
    pl = ngon(O, 250, 3, pi/6, vertices=true)
    mesh1 = mesh(pl, [
        "purple",
        Colors.RGBA(0.0, 1.0, 0.5, 0.5),
        "yellow"
        ])
    setmesh(mesh1)
    setline(180)
    ngon(O, 250, 3, pi/6, :strokepreserve)
    setline(5)
    sethue("black")
    strokepath()
end

setmesh(mesh::Mesh)

Select a mesh previously created with mesh() for filling shapes.