API

iv = l..r

Construct a ClosedInterval iv spanning the region from l to r.

Examples

julia> 1..2
1 .. 2

julia> 3..1  # Empty interval set can be defined
3 .. 1

@L_str

L"..."

Creates a LaTeXString and is equivalent to latexstring(raw"..."), except that %$ can be used for interpolation.

julia> L"x = \sqrt{2}"
L"$x = \sqrt{2}$"

julia> L"x = %$(sqrt(2))"
L"$x = 1.4142135623730951$"

@colorant_str

@colorant_str(ex)

Parse a literal color name as a Colorant. See Base.parse(Colorant, desc).

@extract

@extract scene (a, b, c, d)

This becomes

begin
    a = scene[:a]
    b = scene[:b]
    c = scene[:d]
    d = scene[:d]
    (a, b, c, d)
end

@extractvalue

usage @extractvalue scene (a, b, c, d) will become:

begin
    a = to_value(scene[:a])
    b = to_value(scene[:b])
    c = to_value(scene[:c])
    (a, b, c)
end

@get_attribute

@get_attribute scene (a, b, c, d)

This will extract attribute a, b, c, d from scene and apply the correct attribute conversions + will extract the value if it's a signal. It will make those attributes available as variables and return them as a tuple. So the above is equal to: will become:

begin
    a = get_attribute(scene, :a)
    b = get_attribute(scene, :b)
    c = get_attribute(scene, :c)
    (a, b, c)
end

@key_str

No documentation found.

MakieCore.@key_str is a macro.

# 1 method for macro "@key_str" from MakieCore:
 [1] var"@key_str"(__source__::LineNumberNode, __module__::Module, arg)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/types.jl:98

@lift

Replaces an expression with lift(argtuple -> expression, args...), where args are all expressions inside the main one that begin with $.

Example:

x = Observable(rand(100))
y = Observable(rand(100))

before

z = lift((x, y) -> x .+ y, x, y)

after

z = @lift($x .+ $y)

You can also use parentheses around an expression if that expression evaluates to an observable.

nt = (x = Observable(1), y = Observable(2))
@lift($(nt.x) + $(nt.y))

@recipe

Plot Recipes in `Makie`

There's two types of recipes. Type recipes define a simple mapping from a user defined type to an existing plot type. Full recipes can customize the theme and define a custom plotting function.

Type recipes

Type recipe are really simple and just overload the argument conversion pipeline. This can be done for all plot types or for a subset of plot types:

# All plot types
convert_arguments(P::Type{<:AbstractPlot}, x::MyType) = convert_arguments(P, rand(10, 10))
# Only for scatter plots
convert_arguments(P::Type{<:Scatter}, x::MyType) = convert_arguments(P, rand(10, 10))

Optionally you may define the default plot type so that plot(x::MyType) will use this:

plottype(::MyType) = Surface

Full recipes with the `@recipe` macro

A full recipe for MyPlot comes in two parts. First is the plot type name, arguments and theme definition which are defined using the @recipe macro. Second is a custom plot! for MyPlot, implemented in terms of the atomic plotting functions.

We use an example to show how this works:

# arguments (x, y, z) && theme are optional
@recipe(MyPlot, x, y, z) do scene
    Attributes(
        plot_color = :red
    )
end

This macro expands to several things. Firstly a type definition:

const MyPlot{ArgTypes} = Plot{myplot, ArgTypes}

The type parameter of Plot contains the function instead of e.g. a symbol. This way the mapping from MyPlot to myplot is safer and simpler. (The downside is we always need a function myplot - TODO: is this a problem?)

The following signatures are defined to make MyPlot nice to use:

myplot(args...; kw_args...) = ...
myplot!(scene, args...; kw_args...) = ...
myplot(kw_args::Dict, args...) = ...
myplot!(scene, kw_args::Dict, args...) = ...
#etc (not 100% settled what signatures there will be)

A specialization of argument_names is emitted if you have an argument list (x,y,z) provided to the recipe macro:

argument_names(::Type{<: MyPlot}) = (:x, :y, :z)

This is optional but it will allow the use of plot_object[:x] to fetch the first argument from the call plot_object = myplot(rand(10), rand(10), rand(10)), for example. Alternatively you can always fetch the ith argument using plot_object[i], and if you leave out the (x,y,z), the default version of argument_names will provide plot_object[:arg1] etc.

The theme given in the body of the @recipe invocation is inserted into a specialization of default_theme which inserts the theme into any scene that plots MyPlot:

function default_theme(scene, ::MyPlot)
    Attributes(
        plot_color = :red
    )
end

As the second part of defining MyPlot, you should implement the actual plotting of the MyPlot object by specializing plot!:

function plot!(plot::MyPlot)
    # normal plotting code, building on any previously defined recipes
    # or atomic plotting operations, and adding to the combined `plot`:
    lines!(plot, rand(10), color = plot[:plot_color])
    plot!(plot, plot[:x], plot[:y])
    plot
end

It's possible to add specializations here, depending on the argument types supplied to myplot. For example, to specialize the behavior of myplot(a) when a is a 3D array of floating point numbers:

const MyVolume = MyPlot{Tuple{<:AbstractArray{<: AbstractFloat, 3}}}
argument_names(::Type{<: MyVolume}) = (:volume,) # again, optional
function plot!(plot::MyVolume)
    # plot a volume with a colormap going from fully transparent to plot_color
    volume!(plot, plot[:volume], colormap = :transparent => plot[:plot_color])
    plot
end

The docstring given to the recipe will be transferred to the functions it generates.

ABLines

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Absolute

Absolute

Force transformation to be absolute, not relative to the current state. This is the default setting.

Absorption

No documentation found.

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

AbsorptionRGBA

No documentation found.

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

AbstractCamera

No documentation found.

Summary

abstract type AbstractCamera

Subtypes

Camera2D
EmptyCamera
Makie.AbstractCamera3D
Makie.OldCamera3D
Makie.OrthographicCamera
Makie.PixelCamera
Makie.RelativeCamera

AbstractPlot

No documentation found.

Summary

abstract type AbstractPlot{Typ}

Subtypes

Makie.FakePlot
MakieCore.ScenePlot{Typ}

Supertype Hierarchy

AbstractPlot{Typ} <: MakieCore.Transformable <: Any

AbstractScene

No documentation found.

Summary

abstract type AbstractScene

Subtypes

Scene

Supertype Hierarchy

AbstractScene <: MakieCore.Transformable <: Any

Accum

Accum

Force transformation to be relative to the current state, not absolute.

AmbientLight

AmbientLight(color) <: AbstractLight

A simple ambient light that uniformly lights every object based on its light color.

Availability:

All backends with shading = FastShading or MultiLightShading

Annotations

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Arc

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Arrows

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Aspect

No documentation found.

Summary

struct Aspect

Fields

index :: Int64
ratio :: Float32

Atomic

Union{Types...}

A type union is an abstract type which includes all instances of any of its argument types. The empty union Union{} is the bottom type of Julia.

Examples

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString
true

julia> "Hello!" isa IntOrString
true

julia> 1.0 isa IntOrString
false

Attributes

Main structure for holding attributes, for theming plots etc! Will turn all values into observables, so that they can be updated.

Auto

struct Auto

If used as a GridLayout's row / column size and trydetermine == true, signals to the GridLayout that the row / column should shrink to match the largest determinable element inside. If no size of a content element can be determined, the remaining space is split between all Auto rows / columns according to their ratio.

If used as width / height of a layoutable element and trydetermine == true, the element's computed width / height will report the auto width / height if it can be determined. This enables a parent GridLayout to adjust its column / rowsize to the element's width / height. If trydetermine == false, the element's computed width / height will report nothing even if an auto width / height can be determined, which will prohibit a parent GridLayout from adjusting a row / column to the element's width / height. This is useful to, e.g., prohibit a GridLayout from shrinking a column's width to the width of a super title, even though the title's width can be auto-determined.

The ratio is ignored if Auto is used as an element size.

Axis

Axis <: Block

A 2D axis which can be plotted into.

Constructors

Axis(fig_or_scene; palette = nothing, kwargs...)

Attributes

(type ?Axis.x in the REPL for more information about attribute x)

alignmode, aspect, autolimitaspect, backgroundcolor, bottomspinecolor, bottomspinevisible, dim1_conversion, dim2_conversion, flip_ylabel, halign, height, leftspinecolor, leftspinevisible, limits, panbutton, rightspinecolor, rightspinevisible, spinewidth, subtitle, subtitlecolor, subtitlefont, subtitlegap, subtitlelineheight, subtitlesize, subtitlevisible, tellheight, tellwidth, title, titlealign, titlecolor, titlefont, titlegap, titlelineheight, titlesize, titlevisible, topspinecolor, topspinevisible, valign, width, xautolimitmargin, xaxisposition, xgridcolor, xgridstyle, xgridvisible, xgridwidth, xlabel, xlabelcolor, xlabelfont, xlabelpadding, xlabelrotation, xlabelsize, xlabelvisible, xminorgridcolor, xminorgridstyle, xminorgridvisible, xminorgridwidth, xminortickalign, xminortickcolor, xminorticks, xminorticksize, xminorticksvisible, xminortickwidth, xpankey, xpanlock, xrectzoom, xreversed, xscale, xtickalign, xtickcolor, xtickformat, xticklabelalign, xticklabelcolor, xticklabelfont, xticklabelpad, xticklabelrotation, xticklabelsize, xticklabelspace, xticklabelsvisible, xticks, xticksize, xticksmirrored, xticksvisible, xtickwidth, xtrimspine, xzoomkey, xzoomlock, yautolimitmargin, yaxisposition, ygridcolor, ygridstyle, ygridvisible, ygridwidth, ylabel, ylabelcolor, ylabelfont, ylabelpadding, ylabelrotation, ylabelsize, ylabelvisible, yminorgridcolor, yminorgridstyle, yminorgridvisible, yminorgridwidth, yminortickalign, yminortickcolor, yminorticks, yminorticksize, yminorticksvisible, yminortickwidth, ypankey, ypanlock, yrectzoom, yreversed, yscale, ytickalign, ytickcolor, ytickformat, yticklabelalign, yticklabelcolor, yticklabelfont, yticklabelpad, yticklabelrotation, yticklabelsize, yticklabelspace, yticklabelsvisible, yticks, yticksize, yticksmirrored, yticksvisible, ytickwidth, ytrimspine, yzoomkey, yzoomlock

Axis3

Axis3 <: Block

Attributes

(type ?Axis3.x in the REPL for more information about attribute x)

alignmode, aspect, azimuth, backgroundcolor, dim1_conversion, dim2_conversion, dim3_conversion, elevation, halign, height, limits, perspectiveness, protrusions, targetlimits, tellheight, tellwidth, title, titlealign, titlecolor, titlefont, titlegap, titlesize, titlevisible, valign, viewmode, width, xautolimitmargin, xgridcolor, xgridvisible, xgridwidth, xlabel, xlabelalign, xlabelcolor, xlabelfont, xlabeloffset, xlabelrotation, xlabelsize, xlabelvisible, xreversed, xspinecolor_1, xspinecolor_2, xspinecolor_3, xspinesvisible, xspinewidth, xtickcolor, xtickformat, xticklabelcolor, xticklabelfont, xticklabelpad, xticklabelsize, xticklabelsvisible, xticks, xticksize, xticksvisible, xtickwidth, xypanelcolor, xypanelvisible, xzpanelcolor, xzpanelvisible, yautolimitmargin, ygridcolor, ygridvisible, ygridwidth, ylabel, ylabelalign, ylabelcolor, ylabelfont, ylabeloffset, ylabelrotation, ylabelsize, ylabelvisible, yreversed, yspinecolor_1, yspinecolor_2, yspinecolor_3, yspinesvisible, yspinewidth, ytickcolor, ytickformat, yticklabelcolor, yticklabelfont, yticklabelpad, yticklabelsize, yticklabelsvisible, yticks, yticksize, yticksvisible, ytickwidth, yzpanelcolor, yzpanelvisible, zautolimitmargin, zgridcolor, zgridvisible, zgridwidth, zlabel, zlabelalign, zlabelcolor, zlabelfont, zlabeloffset, zlabelrotation, zlabelsize, zlabelvisible, zreversed, zspinecolor_1, zspinecolor_2, zspinecolor_3, zspinesvisible, zspinewidth, ztickcolor, ztickformat, zticklabelcolor, zticklabelfont, zticklabelpad, zticklabelsize, zticklabelsvisible, zticks, zticksize, zticksvisible, ztickwidth

Axis3D

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

AxisAspect

No documentation found.

Summary

struct AxisAspect

Fields

aspect :: Float32

BBox

BBox(left::Number, right::Number, bottom::Number, top::Number)

Convenience constructor to create a Rect2 with left, right, bottom and top extent instead of the usual origin, widths combination.

Band

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

BarPlot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

BezierPath

BezierPath(commands::Vector)

Construct a BezierPath with a vector of path commands. The available path commands are

MoveTo
LineTo
CurveTo
EllipticalArc
ClosePath

A BezierPath can be used in certain places in Makie as an alternative to a polygon or a collection of lines, for example as an input to poly or lines, or as a marker for scatter.

The benefit of using a BezierPath is that curves do not need to be converted into a vector of vertices by the user. CairoMakie can use the path commands directly when it writes vector graphics which is more efficient and uses less space than approximating them visually using line segments.

BezierPath(svg::AbstractString; fit = false, bbox = nothing, flipy = false, flipx = false, keep_aspect = true)

Construct a BezierPath using a string of SVG path commands. The commands will be parsed first into MoveTo, LineTo, CurveTo, EllipticalArc and ClosePath objects which are then passed to the BezierPath constructor.

If fit === true, the path will be scaled to fit into a square of width 1 centered on the origin. If, additionally, bbox is set to some Rect, the path will be fit into this rectangle instead. If you want to use a path as a scatter marker, it is usually good to fit it so that it's centered and of a comparable size relative to other scatter markers.

If flipy === true or flipx === true, the respective dimensions of the path will be flipped. Makie uses a coordinate system where y=0 is at the bottom and y increases upwards while in SVG, y=0 is at the top and y increases downwards, so for most SVG paths flipy = true will be needed.

If keep_aspect === true, the path will be fit into the bounding box such that its longer dimension fits and the other one is scaled to retain the original aspect ratio. If you set keep_aspect = false, the new boundingbox of the path will be the one it is fit to, but note that this can result in a squished appearance.

Example

Construct a triangular BezierPath out of a path command string and use it as a scatter marker:

str = "M 0,0 L 10,0 L 5,10 z"
bp = BezierPath(str, fit = true)
scatter(1:10, marker = bp, markersize = 20)

Billboard

Billboard([angle::Real])
Billboard([angles::Vector{<: Real}])

Billboard attribute to always have a primitive face the camera. Can be used for rotation.

Bottom

No documentation found.

Summary

struct Bottom

Supertype Hierarchy

Bottom <: GridLayoutBase.Side <: Any

BottomLeft

No documentation found.

Summary

struct BottomLeft

Supertype Hierarchy

BottomLeft <: GridLayoutBase.Side <: Any

BottomRight

No documentation found.

Summary

struct BottomRight

Supertype Hierarchy

BottomRight <: GridLayoutBase.Side <: Any

Box

Box <: Block

Attributes

(type ?Box.x in the REPL for more information about attribute x)

alignmode, color, cornerradius, halign, height, linestyle, strokecolor, strokevisible, strokewidth, tellheight, tellwidth, valign, visible, width

BoxPlot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Bracket

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Button

Button <: Block

Attributes

(type ?Button.x in the REPL for more information about attribute x)

alignmode, buttoncolor, buttoncolor_active, buttoncolor_hover, clicks, cornerradius, cornersegments, font, fontsize, halign, height, label, labelcolor, labelcolor_active, labelcolor_hover, padding, strokecolor, strokewidth, tellheight, tellwidth, valign, width

Camera

Camera(pixel_area)

Struct to hold all relevant matrices and additional parameters, to let backends apply camera based transformations.

Fields

pixel_space::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 16}}: projection used to convert pixel to device units

view::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 16}}: View matrix is usually used to rotate, scale and translate the scene

projection::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 16}}: Projection matrix is used for any perspective transformation

projectionview::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 16}}: just projection * view

resolution::Observable{Vec{2, Float32}}: resolution of the canvas this camera draws to

view_direction::Observable{Vec{3, Float32}}: Direction in which the camera looks.

eyeposition::Observable{Vec{3, Float32}}: Eye position of the camera, used for e.g. ray tracing.

steering_nodes::Vector{Observables.ObserverFunction}: To make camera interactive, steering observables are connected to the different matrices. We need to keep track of them, so, that we can connect and disconnect them.

calculated_values::Dict{Symbol, Observable}

Camera2D

No documentation found.

Summary

struct Camera2D

Fields

area          :: Observable{GeometryBasics.HyperRectangle{2, Float32}}
zoomspeed     :: Observable{Float32}
zoombutton    :: Observable{Union{Bool, Makie.Keyboard.Button, Makie.Mouse.Button, Tuple, Makie.BooleanOperator, Set, Vector}}
panbutton     :: Observable{Union{Bool, Makie.Keyboard.Button, Makie.Mouse.Button, Tuple, Makie.BooleanOperator, Set, Vector}}
padding       :: Observable{Float32}
last_area     :: Observable{Vec{2, Int64}}
update_limits :: Observable{Bool}

Supertype Hierarchy

Camera2D <: AbstractCamera <: Any

Camera3D

Camera3D(scene[; kwargs...])

Sets up a 3D camera with mouse and keyboard controls.

The behavior of the camera can be adjusted via keyword arguments or the fields settings and controls.

Settings

Settings include anything that isn't a mouse or keyboard button.

projectiontype = Perspective sets the type of the projection. Can be Orthographic or Perspective.
rotation_center = :lookat sets the default center for camera rotations. Currently allows :lookat or :eyeposition.
fixed_axis = true: If true panning uses the (world/plot) z-axis instead of the camera up direction.
zoom_shift_lookat = true: If true keeps the data under the cursor when zooming.
cad = false: If true rotates the view around lookat when zooming off-center.
clipping_mode = :adaptive: Controls how near and far get processed. Options:
- :static passes near and far as is
- :adaptive scales near by norm(eyeposition - lookat) and passes far as is
- :view_relative scales near and far by norm(eyeposition - lookat)
- :bbox_relative scales near and far to the scene bounding box as passed to the camera with update_cam!(..., bbox). (More specifically far = 1 is scaled to the furthest point of a bounding sphere and near is generally overwritten to be the closest point.)
center = true: Controls whether the camera placement gets reset when calling center!(scene), which is called when a new plot is added.
keyboard_rotationspeed = 1f0 sets the speed of keyboard based rotations.
keyboard_translationspeed = 0.5f0 sets the speed of keyboard based translations.
keyboard_zoomspeed = 1f0 sets the speed of keyboard based zooms.
mouse_rotationspeed = 1f0 sets the speed of mouse rotations.
mouse_translationspeed = 0.5f0 sets the speed of mouse translations.
mouse_zoomspeed = 1f0 sets the speed of mouse zooming (mousewheel).
update_rate = 1/30 sets the rate at which keyboard based camera updates are evaluated.
circular_rotation = (true, true, true) enables circular rotations for (fixed x, fixed y, fixed z) rotation axis. (This means drawing a circle with your mouse around the center of the scene will result in a continuous rotation.)

Controls

Controls include any kind of hotkey setting.

up_key = Keyboard.r sets the key for translations towards the top of the screen.
down_key = Keyboard.f sets the key for translations towards the bottom of the screen.
left_key = Keyboard.a sets the key for translations towards the left of the screen.
right_key = Keyboard.d sets the key for translations towards the right of the screen.
forward_key = Keyboard.w sets the key for translations into the screen.
backward_key = Keyboard.s sets the key for translations out of the screen.
zoom_in_key = Keyboard.u sets the key for zooming into the scene (translate eyeposition towards lookat).
zoom_out_key = Keyboard.o sets the key for zooming out of the scene (translate eyeposition away from lookat).
increase_fov_key = Keyboard.b sets the key for increasing the fov.
decrease_fov_key = Keyboard.n sets the key for decreasing the fov.
pan_left_key = Keyboard.j sets the key for rotations around the screens vertical axis.
pan_right_key = Keyboard.l sets the key for rotations around the screens vertical axis.
tilt_up_key = Keyboard.i sets the key for rotations around the screens horizontal axis.
tilt_down_key = Keyboard.k sets the key for rotations around the screens horizontal axis.
roll_clockwise_key = Keyboard.e sets the key for rotations of the screen.
roll_counterclockwise_key = Keyboard.q sets the key for rotations of the screen.
fix_x_key = Keyboard.x sets the key for fixing translations and rotations to the (world/plot) x-axis.
fix_y_key = Keyboard.y sets the key for fixing translations and rotations to the (world/plot) y-axis.
fix_z_key = Keyboard.z sets the key for fixing translations and rotations to the (world/plot) z-axis.
reset = Keyboard.left_control & Mouse.left sets the key for resetting the camera. This equivalent to calling center!(scene).
reposition_button = Keyboard.left_alt & Mouse.left sets the key for focusing the camera on a plot object.
translation_button = Mouse.right sets the mouse button for drag-translations. (up/down/left/right)
scroll_mod = true sets an additional modifier button for scroll-based zoom. (true being neutral)
rotation_button = Mouse.left sets the mouse button for drag-rotations. (pan, tilt)

Other kwargs

Some keyword arguments are used to initialize fields. These include

eyeposition = Vec3f(3): The position of the camera.
lookat = Vec3f(0): The point the camera is focused on.
upvector = Vec3f(0, 0, 1): The world direction corresponding to the up direction of the screen.
fov = 45.0 is the field of view. This is irrelevant if the camera uses an orthographic projection.
near = automatic sets the position of the near clip plane. Anything between the camera and the near clip plane is hidden. Must be greater 0. Usage depends on clipping_mode.
far = automatic sets the position of the far clip plane. Anything further away than the far clip plane is hidden. Usage depends on clipping_mode. Defaults to 1 for clipping_mode = :bbox_relative, 2 for :view_relative or a value derived from limits for :static.

Note that updating these observables in an active camera requires a call to update_cam(scene) for them to be applied. For updating eyeposition, lookat and/or upvector update_cam!(scene, eyeposition, lookat, upvector = Vec3f(0,0,1)) is preferred.

The camera position and orientation can also be adjusted via the functions

translate_cam!(scene, v) will translate the camera by the given world/plot space vector v.
rotate_cam!(scene, angles) will rotate the camera around its axes with the corresponding angles. The first angle will rotate around the cameras "right" that is the screens horizontal axis, the second around the up vector/vertical axis or Vec3f(0, 0, +-1) if fixed_axis = true, and the third will rotate around the view direction i.e. the axis out of the screen. The rotation respects the current rotation_center of the camera.
zoom!(scene, zoom_step) will change the zoom level of the scene without translating or rotating the scene. zoom_step applies multiplicatively to cam.zoom_mult which is used as a multiplier to the fov (perspective projection) or width and height (orthographic projection).

Categorical

Categorical(colormaplike)

Accepts all colormap values that the colormap attribute of a plot accepts. Will make sure to map one value to one color and create the correct Colorbar for the plot.

Example:

fig, ax, pl = barplot(1:3; color=1:3, colormap=Makie.Categorical(:viridis))

Warning

This feature might change outside breaking releases, since the API is not yet finalized

CellGrid

CellGrid() <: GridBased <: ConversionTrait

Plots with the CellGrid trait convert their input data to (xs::Vector{Float32}, ys::Vector{Float32}, zs::Matrix{Float32}) such that (length(xs), length(ys)) == size(zs) .+ 1. After the conversion the x and y values represent the edges of cells corresponding to z values.

See also: VertexGrid, ImageLike Used for: Heatmap

Circle

HyperSphere{N, T}

A HyperSphere is a generalization of a sphere into N-dimensions. A center and radius, r, must be specified.

ClosePath

ClosePath()

A path command for use within a BezierPath which closes the current subpath. The resulting path will have an implicit line segment between the last point and the first point if they do not match.

Colorbar

Colorbar <: Block

Create a colorbar that shows a continuous or categorical colormap with ticks chosen according to the colorrange.

You can set colorrange and colormap manually, or pass a plot object as the second argument to copy its respective attributes.

Constructors

Colorbar(fig_or_scene; kwargs...)
Colorbar(fig_or_scene, plot::AbstractPlot; kwargs...)
Colorbar(fig_or_scene, heatmap::Union{Heatmap, Image}; kwargs...)
Colorbar(fig_or_scene, contourf::Makie.Contourf; kwargs...)

Attributes

(type ?Colorbar.x in the REPL for more information about attribute x)

alignmode, bottomspinecolor, bottomspinevisible, colormap, colorrange, flip_vertical_label, flipaxis, halign, height, highclip, label, labelcolor, labelfont, labelpadding, labelrotation, labelsize, labelvisible, leftspinecolor, leftspinevisible, limits, lowclip, minortickalign, minortickcolor, minorticks, minorticksize, minorticksvisible, minortickwidth, nsteps, rightspinecolor, rightspinevisible, scale, size, spinewidth, tellheight, tellwidth, tickalign, tickcolor, tickformat, ticklabelalign, ticklabelcolor, ticklabelfont, ticklabelpad, ticklabelrotation, ticklabelsize, ticklabelspace, ticklabelsvisible, ticks, ticksize, ticksvisible, tickwidth, topspinecolor, topspinevisible, valign, vertical, width

Consume

No documentation found.

Summary

struct Consume

Fields

x :: Bool

Contour

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Contour3d

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Contourf

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

ConversionTrait

No documentation found.

Summary

abstract type ConversionTrait

Subtypes

GridBased
ImageLike
Makie.SampleBased
NoConversion
PointBased
VolumeLike

CrossBar

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

CurveTo

CurveTo(c1::VecTypes, c2::VecTypes, p::VecTypes)
CurveTo(cx1::Real, cy1::Real, cx2::Real, cy2::Real, px::Real, py::Real)

A path command for use within a BezierPath which continues the current subpath with a cubic bezier curve to point p, with the first control point c1 and the second control point c2.

Cycle

No documentation found.

Summary

struct Cycle

Fields

cycle  :: Vector{Pair{Vector{Symbol}, Symbol}}
covary :: Bool

Cycled

Cycled(i::Int)

If a Cycled value is passed as an attribute to a plotting function, it is replaced with the value from the cycler for this attribute (as long as there is one defined) at the index i.

DataAspect

No documentation found.

Summary

struct DataAspect

DataInspector

DataInspector(figure_axis_or_scene = current_figure(); kwargs...)

Creates a data inspector which will show relevant information in a tooltip when you hover over a plot.

This functionality can be disabled on a per-plot basis by setting plot.inspectable[] = false. The displayed text can be adjusted by setting plot.inspector_label to a function (plot, index, position) -> "my_label" returning a label. See Makie documentation for more detail.

Keyword Arguments:

range = 10: Controls the snapping range for selecting an element of a plot.
priority = 100: The priority of creating a tooltip on a mouse movement or scrolling event.
enabled = true: Disables inspection of plots when set to false. Can also be adjusted with enable!(inspector) and disable!(inspector).
indicator_color = :red: Color of the selection indicator.
indicator_linewidth = 2: Linewidth of the selection indicator.
indicator_linestyle = nothing: Linestyle of the selection indicator
enable_indicators = true): Enables or disables indicators
depth = 9e3: Depth value of the tooltip. This should be high so that the tooltip is always in front.
apply_tooltip_offset = true: Enables or disables offsetting tooltips based on, for example, markersize.
and all attributes from Tooltip

DataShader

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Density

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

DirectionalLight

DirectionalLight(color, direction[, camera_relative = false])

A light type which simulates a distant light source with parallel light rays going in the given direction.

Availability:

All backends with shading = FastShading or MultiLightShading

ECDFPlot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

EllipticalArc

EllipticalArc(c::VecTypes, r1::Real, r2::Real, angle::Real, a1::Real, a2::Real)
EllipticalArc(cx::Real, cy::Real, r1::Real, r2::Real, angle::Real, a1::Real, a2::Real)

A path command for use within a BezierPath which continues the current subpath with an elliptical arc. The ellipse is centered at c and has two radii, r1 and r2, the orientation of which depends on angle.

If angle == 0, r1 goes in x direction and r2 in y direction. A positive angle in radians rotates the ellipse counterclockwise, and a negative angle clockwise.

The angles a1 and a2 are the start and stop positions of the arc on the ellipse. A value of 0 is where the radius r1 points to, pi/2 is where the radius r2 points to, and so on. If a2 > a1, the arc turns counterclockwise. If a1 > a2, it turns clockwise.

If the last position of the subpath does not equal the start of the arc, the resulting path will have an implicit line segment between the two.

EllipticalArc(x1::Real, y1::Real, x2::Real, y2::Real, rx::Real, ry::Real, ϕ::Real, largearc::Bool, sweepflag::Bool)

Construct an EllipticalArc using the endpoint parameterization.

x1, y1 is the starting point and x2, y2 the end point, rx and ry are the two ellipse radii. ϕ is the angle of rx vs the x axis.

Usually, four arcs can be constructed between two points given these ellipse parameters. One of them is chosen using two boolean flags:

If largearc === true, the arc will be longer than 180 degrees. If sweepflag === true, the arc will sweep through increasing angles.

EmptyCamera

No documentation found.

Summary

struct EmptyCamera

Supertype Hierarchy

EmptyCamera <: AbstractCamera <: Any

EnvironmentLight

EnvironmentLight(intensity, image)

An environment light that uses a spherical environment map to provide lighting. See: https://en.wikipedia.org/wiki/Reflection_mapping

Availability:

RPRMakie

Errorbars

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Events

This struct provides accessible Observables to monitor the events associated with a Scene.

Functions that act on an Observable must return Consume() if the function consumes an event. When an event is consumed it does not trigger other observer functions. The order in which functions are executed can be controlled via the priority keyword (default 0) in on.

Example:

on(events(scene).mousebutton, priority = 20) do event
    if is_correct_event(event)
        do_something()
        return Consume()
    end
    return
end

Fields

window_area::Observable{GeometryBasics.HyperRectangle{2, Int64}}: The area of the window in pixels, as a Rect2.

window_dpi::Observable{Float64}: The DPI resolution of the window, as a Float64.

window_open::Observable{Bool}: The state of the window (open => true, closed => false).

mousebutton::Observable{Makie.MouseButtonEvent}: Most recently triggered MouseButtonEvent. Contains the relevant event.button and event.action (press/release)
See also ispressed.

mousebuttonstate::Set{Makie.Mouse.Button}: A Set of all currently pressed mousebuttons.

mouseposition::Observable{Tuple{Float64, Float64}}: The position of the mouse as a NTuple{2, Float64}. Updates once per event poll/frame.

scroll::Observable{Tuple{Float64, Float64}}: The direction of scroll

keyboardbutton::Observable{Makie.KeyEvent}: Most recently triggered KeyEvent. Contains the relevant event.key and event.action (press/repeat/release)
See also ispressed.

keyboardstate::Set{Makie.Keyboard.Button}: Contains all currently pressed keys.

unicode_input::Observable{Char}: Contains the last typed character.

dropped_files::Observable{Vector{String}}: Contains a list of filepaths to files dragged into the scene.

hasfocus::Observable{Bool}: Whether the Scene window is in focus or not.

entered_window::Observable{Bool}: Whether the mouse is inside the window or not.

Exclusively

Exclusively(x)

Marks a button, button collection or logical expression of buttons as the exclusive subset of buttons that must be pressed for ispressed to return true.

For example Exclusively((Keyboard.left_control, Keyboard.c)) would require left control and c to be pressed without any other buttons.

Boolean expressions are lowered to multiple Exclusive sets in an Or. It is worth noting that Not branches are ignored here, i.e. it assumed that every button under a Not must not be pressed and that this follows automatically from the subset of buttons that must be pressed.

See also: And, Or, Not, ispressed, &, |, !

FastShading

No documentation found.

Summary

primitive type MakieCore.ShadingAlgorithm

Supertype Hierarchy

MakieCore.ShadingAlgorithm <: Enum{Int32} <: Any

Figure

No documentation found.

Summary

struct Figure

Fields

scene        :: Scene
layout       :: GridLayout
content      :: Vector
attributes   :: Attributes
current_axis :: Ref{Any}

Fixed

No documentation found.

Summary

struct Fixed

Fields

x :: Float32

GridBased

GridBased <: ConversionTrait

GridBased is an abstract conversion trait for data that exists on a grid.

Child types: VertexGrid, CellGrid See also: ImageLike Used for: Scatter, Lines

GridLayout

GridLayout(; kwargs...)

Create a GridLayout without parent and with size [1, 1].

GridLayout(g::Union{GridPosition, GridSubposition}, args...; kwargs...)

Create a GridLayout at position g in the parent GridLayout of g if it is a GridPosition and in a nested child GridLayout if it is a GridSubposition. The args and kwargs are passed on to the normal GridLayout constructor.

function GridLayout(nrows::Integer, ncols::Integer;
    parent = nothing,
    rowsizes = nothing,
    colsizes = nothing,
    addedrowgaps = nothing,
    addedcolgaps = nothing,
    alignmode = Inside(),
    equalprotrusiongaps = (false, false),
    bbox = nothing,
    width = Auto(),
    height = Auto(),
    tellwidth::Bool = true,
    tellheight::Bool = true,
    halign = :center,
    valign = :center,
    default_rowgap = get_default_rowgap(),
    default_colgap = get_default_colgap(),
    kwargs...)

Create a GridLayout with optional parent parent with nrows rows and ncols columns.

GridPosition

No documentation found.

Summary

struct GridPosition

Fields

layout :: GridLayout
span   :: GridLayoutBase.Span
side   :: GridLayoutBase.Side

GridSubposition

No documentation found.

Summary

struct GridSubposition

Fields

parent :: Union{GridPosition, GridSubposition}
rows   :: Any
cols   :: Any
side   :: GridLayoutBase.Side

HLines

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

HSpan

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Heatmap

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Hexbin

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Hist

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Image

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

ImageLike

ImageLike() <: ConversionTrait

Plots with the ImageLike trait convert their input data to (xs::Interval, ys::Interval, zs::Matrix{Float32}) where xs and ys mark the limits of a quad containing zs.

See also: CellGrid, VertexGrid Used for: Image

IndexedAbsorptionRGBA

No documentation found.

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

Inside

AlignMode that excludes the protrusions from the bounding box. Construct with Inside().

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

KeysEvent

No documentation found.

Summary

struct KeysEvent

Fields

keys :: Set{Makie.Keyboard.Button}

LScene

LScene <: Block

Attributes

(type ?LScene.x in the REPL for more information about attribute x)

alignmode, dim1_conversion, dim2_conversion, dim3_conversion, halign, height, show_axis, tellheight, tellwidth, valign, width

Label

Label <: Block

Attributes

(type ?Label.x in the REPL for more information about attribute x)

alignmode, color, font, fontsize, halign, height, justification, lineheight, padding, rotation, tellheight, tellwidth, text, valign, visible, width, word_wrap

LayoutObservables

struct LayoutObservables{G}

T is the same type parameter of contained GridContent, G is GridLayout which is defined only after LayoutObservables.

A collection of Observables and an optional GridContent that are needed to interface with the MakieLayout layouting system.

suggestedbbox::Observable{Rect2f}: The bounding box that an element should place itself in. Depending on the element's width and height attributes, this is not necessarily equal to the computedbbox.
protrusions::Observable{RectSides{Float32}}: The sizes of content "sticking out" of the main element into the GridLayout gaps.
reporteddimensions::Observable{Dimensions}: The dimensions (inner and outer) that the object communicates to the containing GridLayout.
autosize::Observable{NTuple{2, Optional{Float32}}}: The width and height that the element reports to its parent GridLayout. If the element doesn't want to cause the parent to adjust to its size, autosize can hide the reportedsize from it by being set to nothing.
computedbbox::Observable{Rect2f}: The bounding box that the element computes for itself after it has received a suggestedbbox.
gridcontent::Optional{GridContent{G}}: A reference of a GridContent if the element is currently placed in a GridLayout. This can be used to retrieve the parent layout, remove the element from it or change its position, and assign it to a different layout.

Left

No documentation found.

Summary

struct Left

Supertype Hierarchy

Left <: GridLayoutBase.Side <: Any

Legend

Legend <: Block

Attributes

(type ?Legend.x in the REPL for more information about attribute x)

alignmode, backgroundcolor, bgcolor, colgap, framecolor, framevisible, framewidth, gridshalign, gridsvalign, groupgap, halign, height, label, labelcolor, labelfont, labelhalign, labeljustification, labelsize, labelvalign, linecolor, linecolormap, linecolorrange, linepoints, linestyle, linewidth, margin, marker, markercolor, markercolormap, markercolorrange, markerpoints, markersize, markerstrokecolor, markerstrokewidth, nbanks, orientation, padding, patchcolor, patchlabelgap, patchsize, patchstrokecolor, patchstrokewidth, polycolor, polycolormap, polycolorrange, polypoints, polystrokecolor, polystrokewidth, rowgap, tellheight, tellwidth, titlecolor, titlefont, titlegap, titlehalign, titleposition, titlesize, titlevalign, titlevisible, valign, width

LegendElement

No documentation found.

Summary

abstract type LegendElement

Subtypes

LineElement
MarkerElement
PolyElement

LegendEntry

No documentation found.

Summary

struct LegendEntry

Fields

elements   :: Vector{LegendElement}
attributes :: Attributes

LineElement

No documentation found.

Summary

struct LineElement

Fields

attributes :: Attributes

Supertype Hierarchy

LineElement <: LegendElement <: Any

LineSegments

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

LineTo

LineTo(p::VecTypes)
LineTo(x::Real, y::Real)

A path command for use within a BezierPath which continues the current subpath with a line to the given point.

LinearTicks

LinearTicks with ideally a number of n_ideal tick marks.

Lines

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Linestyle

Linestyle(value::Vector{<:Real})

A type that can be used as value for the linestyle keyword argument of plotting functions to arbitrarily customize the linestyle.

The value is a vector of positions where the line flips from being drawn or not and vice versa. The values of value are in units of linewidth.

For example, with value = [0.0, 4.0, 6.0, 9.5] you start drawing at 0, stop at 4 linewidths, start again at 6, stop at 9.5, then repeat with 0 and 9.5 being treated as the same position.

LogTicks

LogTicks{T}(linear_ticks::T)

Wraps any other tick object. Used to apply a linear tick searching algorithm on a log-transformed interval.

MakieScreen

Screen constructors implemented by all backends:

# Constructor aimed at showing the plot in a window.
Screen(scene::Scene; screen_config...)

# Screen to save a png/jpeg to file or io
Screen(scene::Scene, io::IO, mime; screen_config...)

# Screen that is efficient for `colorbuffer(screen, format)`
Screen(scene::Scene, format::Makie.ImageStorageFormat; screen_config...)

Interface implemented by all backends:

# Needs to be overload:
size(screen) # Size in pixel
empty!(screen) # empties screen state to reuse the screen, or to close it

# Optional
wait(screen) # waits as long window is open

# Provided by Makie:
push_screen!(scene, screen)

MarkerElement

No documentation found.

Summary

struct MarkerElement

Fields

attributes :: Attributes

Supertype Hierarchy

MarkerElement <: LegendElement <: Any

MaximumIntensityProjection

No documentation found.

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

Menu <: Block

A drop-down menu with multiple selectable options. You can pass options with the keyword argument options.

Options are given as an iterable of elements. For each element, the option label in the menu is determined with optionlabel(element) and the option value with optionvalue(element). These functions can be overloaded for custom types. The default is that tuples of two elements are expected to be label and value, where string(label) is used as the label, while for all other objects, label = string(object) and value = object.

When an item is selected in the menu, the menu's selection attribute is set to optionvalue(selected_element). When nothing is selected, that value is nothing.

You can set the initial selection by passing one of the labels with the default keyword.

Constructors

Menu(fig_or_scene; default = nothing, kwargs...)

Examples

Menu with string entries, second preselected:

menu1 = Menu(fig[1, 1], options = ["first", "second", "third"], default = "second")

Menu with two-element entries, label and function:

funcs = [sin, cos, tan]
labels = ["Sine", "Cosine", "Tangens"]

menu2 = Menu(fig[1, 1], options = zip(labels, funcs))

Executing a function when a selection is made:

on(menu2.selection) do selected_function
    # do something with the selected function
end

Attributes

(type ?Menu.x in the REPL for more information about attribute x)

alignmode, cell_color_active, cell_color_hover, cell_color_inactive_even, cell_color_inactive_odd, direction, dropdown_arrow_color, dropdown_arrow_size, fontsize, halign, height, i_selected, is_open, options, prompt, scroll_speed, selection, selection_cell_color_inactive, tellheight, tellwidth, textcolor, textpadding, valign, width

Mesh

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

MeshScatter

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Mixed

AlignMode that is Inside where padding is Nothing, Outside where it is Real, and overrides the protrusion with a fixed value where it is a Protrusion.

Summary

primitive type MakieCore.ShadingAlgorithm

Supertype Hierarchy

MakieCore.ShadingAlgorithm <: Enum{Int32} <: Any

MultiplesTicks

Like LinearTicks but for multiples of multiple. Example where approximately 5 numbers should be found that are multiples of pi, printed like "1π", "2π", etc.:

MultiplesTicks(5, pi, "π")

NoConversion

No documentation found.

Summary

struct NoConversion

Supertype Hierarchy

NoConversion <: ConversionTrait <: Any

NoShading

No documentation found.

Summary

primitive type MakieCore.ShadingAlgorithm

Supertype Hierarchy

MakieCore.ShadingAlgorithm <: Enum{Int32} <: Any

Observable

obs = Observable(val; ignore_equal_values=false)
obs = Observable{T}(val; ignore_equal_values=false)

Like a Ref, but updates can be watched by adding a handler using on or map. Set ignore_equal_values=true to not trigger an event for observable[] = new_value if isequal(observable[], new_value).

OldAxis

No documentation found.

Summary

struct OldAxis

Outside

AlignMode that includes the protrusions within the bounding box, plus paddings.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point2

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point2f

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point3

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point3f

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point4

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Point4f

No documentation found.

Summary

struct Point{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Point{S, T} <: GeometryBasics.AbstractPoint{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

PointBased

PointBased() <: ConversionTrait

Plots with the PointBased trait convert their input data to a Vector{Point{D, Float32}}.

PointLight

PointLight(color, position[, attenuation = Vec2f(0)])
PointLight(color, position, range::Real)

A point-like light source placed at the given position with the given light color.

Optionally an attenuation parameter can be used to reduce the brightness of the light source with distance. The reduction is given by 1 / (1 + attenuation[1] * distance + attenuation[2] * distance^2). Alternatively you can pass a light range to generate matching default attenuation parameters. Note that you may need to set the light intensity, i.e. the light color to values greater than 1 to get satisfying results.

Availability:

GLMakie with shading = MultiLightShading
RPRMakie

PolarAxis

PolarAxis <: Block

Attributes

(type ?PolarAxis.x in the REPL for more information about attribute x)

alignmode, axis_rotation_button, backgroundcolor, clip, clip_r, clipcolor, dim1_conversion, dim2_conversion, direction, fixrmin, gridz, halign, height, normalize_theta_ticks, r_translation_button, radius_at_origin, rautolimitmargin, reset_axis_orientation, reset_button, rgridcolor, rgridstyle, rgridvisible, rgridwidth, rlimits, rminorgridcolor, rminorgridstyle, rminorgridvisible, rminorgridwidth, rminorticks, rtickangle, rtickformat, rticklabelcolor, rticklabelfont, rticklabelpad, rticklabelrotation, rticklabelsize, rticklabelstrokecolor, rticklabelstrokewidth, rticklabelsvisible, rticks, rzoomkey, rzoomlock, sample_density, spinecolor, spinestyle, spinevisible, spinewidth, tellheight, tellwidth, theta_0, theta_as_x, theta_translation_button, thetaautolimitmargin, thetagridcolor, thetagridstyle, thetagridvisible, thetagridwidth, thetalimits, thetaminorgridcolor, thetaminorgridstyle, thetaminorgridvisible, thetaminorgridwidth, thetaminorticks, thetatickformat, thetaticklabelcolor, thetaticklabelfont, thetaticklabelpad, thetaticklabelsize, thetaticklabelstrokecolor, thetaticklabelstrokewidth, thetaticklabelsvisible, thetaticks, thetazoomkey, thetazoomlock, title, titlealign, titlecolor, titlefont, titlegap, titlesize, titlevisible, valign, width, zoomspeed

Poly

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

PolyElement

No documentation found.

Summary

struct PolyElement

Fields

attributes :: Attributes

Supertype Hierarchy

PolyElement <: LegendElement <: Any

QQNorm

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

QQPlot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Quaternion

No documentation found.

Summary

struct Quaternion{T}

Fields

data :: NTuple{4, T}

Quaternionf

No documentation found.

Summary

struct Quaternion{T}

Fields

data :: NTuple{4, T}

RGBAf

No documentation found.

Summary

struct ColorTypes.RGBA{T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}}

Fields

r     :: T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}
g     :: T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}
b     :: T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}
alpha :: T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}

Supertype Hierarchy

ColorTypes.RGBA{T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}} <: ColorTypes.ColorAlpha{ColorTypes.RGB{T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}}, T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}, 4} <: ColorTypes.TransparentColor{ColorTypes.RGB{T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}}, T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}, 4} <: ColorTypes.Colorant{T<:Union{AbstractFloat, FixedPointNumbers.FixedPoint}, 4} <: Any

RGBf

RGB is the standard Red-Green-Blue (sRGB) colorspace. Values of the individual color channels range from 0 (black) to 1 (saturated). If you want "Integer" storage types (e.g., 255 for full color), use N0f8(1) instead (see FixedPointNumbers).

RainClouds

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Rangebars

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

RaymarchAlgorithm

No documentation found.

Summary

primitive type RaymarchAlgorithm

Supertype Hierarchy

RaymarchAlgorithm <: Enum{Int32} <: Any

RealVector

AbstractArray{T,N}

Supertype for N-dimensional arrays (or array-like types) with elements of type T. Array and other types are subtypes of this. See the manual section on the AbstractArray interface.

Record

Record(func, figlike, [iter]; kw_args...)

Check Makie.record for documentation.

RecordEvents

No documentation found.

Summary

struct RecordEvents

Fields

scene :: Scene
path  :: String

Rect

HyperRectangle{N, T}

A HyperRectangle is a generalization of a rectangle into N-dimensions. Formally it is the cartesian product of intervals, which is represented by the origin and widths fields, whose indices correspond to each of the N axes.

Rect2

HyperRectangle{N, T}

Rect2f

HyperRectangle{N, T}

Rect2i

HyperRectangle{N, T}

Rect3

HyperRectangle{N, T}

Rect3f

HyperRectangle{N, T}

Rect3i

HyperRectangle{N, T}

RectLight

RectLight(color, r::Rect2[, direction = -normal])
RectLight(color, center::Point3f, b1::Vec3f, b2::Vec3f[, direction = -normal])

Creates a RectLight with a given color. The first constructor derives the light from a Rect2 extending in x and y directions. The second specifies the center of the rect (or more accurately parallelogram) with b1 and b2 specifying the width and height vectors (including scale).

Note that RectLight implements translate!, rotate! and scale! to simplify adjusting the light.

Availability:

GLMakie with Shading = MultiLightShading

Rectf

HyperRectangle{N, T}

Recti

HyperRectangle{N, T}

Relative

No documentation found.

Summary

struct Relative

Fields

x :: Float32

Reverse

Reverses the attribute T upon conversion

ReversibleScale

ReversibleScale

Custom scale struct, taking a forward and inverse arbitrary scale function.

Fields

forward::Function: forward transformation (e.g. log10)

inverse::Function: inverse transformation (e.g. exp10 for log10 such that inverse ∘ forward ≡ identity)

limits::Tuple{Float32, Float32}: default limits (optional)

interval::IntervalSets.AbstractInterval: valid limits interval (optional)

name::Symbol

Right

No documentation found.

Summary

struct Right

Supertype Hierarchy

Right <: GridLayoutBase.Side <: Any

SSAO

No documentation found.

Summary

struct SSAO

Fields

radius :: Observable{Float32}
bias   :: Observable{Float32}
blur   :: Observable{Int32}

Scatter

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

ScatterLines

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Scene

Scene TODO document this

Constructors

Fields

parent: The parent of the Scene; if it is a top-level Scene, parent == nothing.
events: Events associated with the Scene.
viewport: The current pixel area of the Scene.
clear: Whether the scene should be cleared.
camera: The Camera associated with the Scene.
camera_controls: The controls for the camera of the Scene.
transformation: The Transformation of the Scene.
float32convert: A transformation rescaling data to a Float32-save range.
plots: The plots contained in the Scene.
theme
children: Children of the Scene inherit its transformation.
current_screens: The Screens which the Scene is displayed to.

backgroundcolor
visible
ssao
lights
deregister_callbacks
cycler
conversions

SceneLike

Union{Types...}

A type union is an abstract type which includes all instances of any of its argument types. The empty union Union{} is the bottom type of Julia.

Examples

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString
true

julia> "Hello!" isa IntOrString
true

julia> 1.0 isa IntOrString
false

SceneSpace

Unit space of the scene it's displayed on. Also referred to as data units

ScrollEvent

No documentation found.

Summary

struct ScrollEvent

Fields

x :: Float32
y :: Float32

Series

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Slider

Slider <: Block

Attributes

(type ?Slider.x in the REPL for more information about attribute x)

alignmode, color_active, color_active_dimmed, color_inactive, halign, height, horizontal, linewidth, range, snap, startvalue, tellheight, tellwidth, valign, value, width

SliderGrid

SliderGrid <: Block

A grid of horizontal Sliders, where each slider has one name label on the left, and a value label on the right.

Each NamedTuple you pass specifies one Slider. You always have to pass range and label, and optionally a format for the value label. Beyond that, you can set any keyword that Slider takes, such as startvalue.

The format keyword can be a String with Format.jl style, such as "{:.2f}Hz", or a function.

Constructors

SliderGrid(fig_or_scene, nts::NamedTuple...; kwargs...)

Examples

sg = SliderGrid(fig[1, 1],
    (label = "Amplitude", range = 0:0.1:10, startvalue = 5),
    (label = "Frequency", range = 0:0.5:50, format = "{:.1f}Hz", startvalue = 10),
    (label = "Phase", range = 0:0.01:2pi,
        format = x -> string(round(x/pi, digits = 2), "π"))
)

Working with slider values:

on(sg.sliders[1].value) do val
    # do something with `val`
end

Attributes

(type ?SliderGrid.x in the REPL for more information about attribute x)

alignmode, halign, height, tellheight, tellwidth, valign, value_column_width, width

Sphere

HyperSphere{N, T}

A HyperSphere is a generalization of a sphere into N-dimensions. A center and radius, r, must be specified.

SpotLight

SpotLight(color, position, direction, angles)

Creates a spot light which illuminates objects in a light cone starting at position pointing in direction. The opening angle is defined by an inner and outer angle given in angles, between which the light intensity drops off.

Availability:

GLMakie with shading = MultiLightShading
RPRMakie

Spy

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Stairs

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Stem

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

StepHist

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Stepper

No documentation found.

Makie.Stepper is a Function.

# 3 methods for generic function "Stepper" from Makie:
 [1] Stepper(figlike::Union{Figure, Makie.FigureAxisPlot, Scene}, path::String; kw...)
     @ ~/work/Makie.jl/Makie.jl/src/recording.jl:47
 [2] Stepper(figlike::Union{Figure, Makie.FigureAxisPlot, Scene}, path::String, step::Int64; format, backend, visible, connect, screen_kw...)
     @ ~/work/Makie.jl/Makie.jl/src/recording.jl:38
 [3] Stepper(figlike::Union{Figure, Makie.FigureAxisPlot, Scene}; backend, format, visible, connect, screen_kw...)
     @ ~/work/Makie.jl/Makie.jl/src/recording.jl:29

StreamPlot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Surface

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Text

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Textbox

Textbox <: Block

Attributes

(type ?Textbox.x in the REPL for more information about attribute x)

alignmode, bordercolor, bordercolor_focused, bordercolor_focused_invalid, bordercolor_hover, borderwidth, boxcolor, boxcolor_focused, boxcolor_focused_invalid, boxcolor_hover, cornerradius, cornersegments, cursorcolor, defocus_on_submit, displayed_string, focused, font, fontsize, halign, height, placeholder, reset_on_defocus, restriction, stored_string, tellheight, tellwidth, textcolor, textcolor_placeholder, textpadding, validator, valign, width

Theme

Main structure for holding attributes, for theming plots etc! Will turn all values into observables, so that they can be updated.

TimeSeries

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Toggle

Toggle <: Block

Attributes

(type ?Toggle.x in the REPL for more information about attribute x)

active, alignmode, buttoncolor, cornersegments, framecolor_active, framecolor_inactive, halign, height, rimfraction, tellheight, tellwidth, toggleduration, valign, width

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Top

No documentation found.

Summary

struct Top

Supertype Hierarchy

Top <: GridLayoutBase.Side <: Any

TopLeft

No documentation found.

Summary

struct TopLeft

Supertype Hierarchy

TopLeft <: GridLayoutBase.Side <: Any

TopRight

No documentation found.

Summary

struct TopRight

Supertype Hierarchy

TopRight <: GridLayoutBase.Side <: Any

Transformation

Holds the transformations for Scenes.

Fields

parent::Base.RefValue{Transformation}
translation::Observable{Vec{3, Float64}}
scale::Observable{Vec{3, Float64}}
rotation::Observable{Quaternionf}
model::Observable{StaticArraysCore.SMatrix{4, 4, Float64, 16}}
parent_model::Observable{StaticArraysCore.SMatrix{4, 4, Float64, 16}}
transform_func::Observable{Any}

Tricontourf

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Triplot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Unit

No documentation found.

Summary

abstract type Unit{T}

Subtypes

Makie.DeviceIndependentPixel{T<:Number}
Makie.Millimeter{T}
Pixel{T}
SceneSpace{T}

Supertype Hierarchy

Unit{T} <: Number <: Any

VLines

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

VSpan

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Vec

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec2

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec2f

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec3

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec3f

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec4

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

Vec4f

No documentation found.

Summary

struct Vec{S, T}

Fields

data :: Tuple{Vararg{T, S}}

Supertype Hierarchy

Vec{S, T} <: StaticArraysCore.StaticArray{Tuple{S}, T, 1} <: AbstractArray{T, 1} <: Any

VecTypes

Union{Types...}

A type union is an abstract type which includes all instances of any of its argument types. The empty union Union{} is the bottom type of Julia.

Examples

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString
true

julia> "Hello!" isa IntOrString
true

julia> 1.0 isa IntOrString
false

VertexGrid

VertexGrid() <: GridBased <: ConversionTrait

Plots with the VertexGrid trait convert their input data to (xs::Vector{Float32}, ys::Vector{Float32}, zs::Matrix{Float32}) such that (length(xs), length(ys)) == size(zs), or (xs::Matrix{Float32}, ys::Matrix{Float32}, zs::Matrix{Float32}) such that size(xs) == size(ys) == size(zs).

See also: CellGrid, ImageLike Used for: Surface

VideoStream

VideoStream(fig::FigureLike;
        format="mp4", framerate=24, compression=nothing, profile=nothing, pixel_format=nothing, loop=nothing,
        loglevel="quiet", visible=false, connect=false, backend=current_backend(),
        screen_config...)

Returns a VideoStream which can pipe new frames into the ffmpeg process with few allocations via recordframe!(stream). When done, use save(path, stream) to write the video out to a file.

Arguments

Video options

format = "mkv": The format of the video. If a path is present, will be inferred from the file extension. Can be one of the following:
- "mkv" (open standard, the default)
- "mp4" (good for Web, most supported format)
- "webm" (smallest file size)
- "gif" (largest file size for the same quality)
mp4 and mk4 are marginally bigger than webm. gifs can be significantly (as much as 6x) larger with worse quality (due to the limited color palette) and only should be used as a last resort, for playing in a context where videos aren't supported.
framerate = 24: The target framerate.
compression = 20: Controls the video compression via ffmpeg's -crf option, with smaller numbers giving higher quality and larger file sizes (lower compression), and higher numbers giving lower quality and smaller file sizes (higher compression). The minimum value is 0 (lossless encoding).
- For mp4, 51 is the maximum. Note that compression = 0 only works with mp4 if
profile = "high444".
- For webm, 63 is the maximum.
- compression has no effect on mkv and gif outputs.
profile = "high422": A ffmpeg compatible profile. Currently only applies to mp4. If

you have issues playing a video, try profile = "high" or profile = "main".

pixel_format = "yuv420p": A ffmpeg compatible pixel format (-pix_fmt). Currently only

applies to mp4. Defaults to yuv444p for profile = "high444".

loop = 0: Number of times the video is repeated, for a gif. Defaults to 0, which

means infinite looping. A value of -1 turns off looping, and a value of n > 0 and above means n repetitions (i.e. the video is played n+1 times).

!!! warning
`profile` and `pixel_format` are only used when `format` is `"mp4"`; a warning will be issued if `format`
is not `"mp4"` and those two arguments are not `nothing`. Similarly, `compression` is only
valid when `format` is `"mp4"` or `"webm"`, and `loop` is only valid when `format` is `"gif"`.

Backend options

backend=current_backend(): backend used to record frames
visible=false: make window visible or not
connect=false: connect window events or not
screen_config...: See ?Backend.Screen or Base.doc(Backend.Screen) for applicable options that can be passed and forwarded to the backend.

Violin

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Volume

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

VolumeLike

No documentation found.

Summary

struct VolumeLike

Supertype Hierarchy

VolumeLike <: ConversionTrait <: Any

VolumeSlices

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Voronoiplot

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Voxels

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

Waterfall

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

WilkinsonTicks

WilkinsonTicks(
    k_ideal::Int;
    k_min = 2, k_max = 10,
    Q = [(1.0, 1.0), (5.0, 0.9), (2.0, 0.7), (2.5, 0.5), (3.0, 0.2)],
    granularity_weight = 1/4,
    simplicity_weight = 1/6,
    coverage_weight = 1/3,
    niceness_weight = 1/4
)

WilkinsonTicks is a thin wrapper over PlotUtils.optimize_ticks, the docstring of which is reproduced below:

optimizeticks(xmin, xmax; extendticks::Bool = false, Q = [(1.0,1.0), (5.0, 0.9), (2.0, 0.7), (2.5, 0.5), (3.0, 0.2)], kmin = 2, kmax = 10, kideal = 5, granularityweight = 1/4, simplicityweight = 1/6, coverageweight = 1/3, nicenessweight = 1/4, strictspan = true, span_buffer = nothing)

Find some reasonable values for tick marks.

This is basically Wilkinson's ad-hoc scoring method that tries to balance tight fit around the data, optimal number of ticks, and simple numbers.

Arguments:

xmax:
The maximum value occurring in the data.
xmin:
The minimum value occurring in the data.
extend_ticks:
Determines whether to extend tick computation. Defaults to false.
strict_span:
True if no ticks should be outside [xmin, xmax]. Defaults to true.
Q:
A distribution of nice numbers from which labellings are sampled. Stored in the form (number, score).
k_min:
The minimum number of ticks.
k_max:
The maximum number of ticks.
k_ideal:
The ideal number of ticks.
granularity_weight:
Encourages returning roughly the number of labels requested.
simplicity_weight:
Encourages nicer labeling sequences by preferring step sizes that appear earlier in Q. Also rewards labelings that include 0 as a way to ground the sequence.
coverage_weight:
Encourages labelings that do not extend far beyond the range of the data, penalizing unnecessary whitespace.
niceness_weight:
Encourages labellings to produce nice ranges.

Returns:

(ticklocations::Vector{Float64}, x_min, x_max)

Mathematical details

Wilkinson’s optimization function is defined as the sum of three components. If the user requests m labels and a possible labeling has k labels, then the components are simplicity, coverage and granularity.

These components are defined as follows:

\begin{aligned} &\text{simplicity} = 1 - \frac{i}{|Q|} + \frac{v}{|Q|}\ &\text{coverage} = \frac{x{max} - x{min}}{\mathrm{label}{max} - \mathrm{label}{min}}\ &\text{granularity}= 1 - \frac{\left|k - m\right|}{m} \end{aligned} $

and the variables here are:

q: element of Q.
i: index of q ∈ Q.
v: 1 if label range includes 0, 0 otherwise.

Wireframe

Plot{PlotFunc}(args::Tuple, kw::Dict{Symbol, Any})

Creates a Plot corresponding to the recipe function PlotFunc. Each recipe defines an alias for Plot{PlotFunc}. Example:

const Scatter = Plot{scatter} # defined in the scatter recipe
Plot{scatter}((1:4,), Dict{Symbol, Any}(:color => :red)) isa Scatter
# Same as:
Scatter((1:4,), Dict{Symbol, Any}(:color => :red))

Plot(args::Vararg{<:DataType,N})

Returns the Plot type that represents the signature of args. Example:

Plot(Vector{Point2f}) == Plot{plot, Tuple{<:Vector{Point2f}}}

This can be used to more conveniently create recipes for plot(mytype) without the recipe macro:

struct MyType ... end

function Makie.plot!(plot::Plot(MyType))
    ...
end

plot(MyType(...))

abline!

No documentation found.

Makie.abline! is a Function.

# 1 method for generic function "abline!" from Makie:
 [1] abline!(args...; kwargs...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/ablines.jl:42

ablines

ablines(intercepts, slopes; attrs...)

Creates a line defined by f(x) = slope * x + intercept crossing a whole Scene with 2D projection at its current limits. You can pass one or multiple intercepts or slopes.

Plot type

The plot type alias for the ablines function is ABLines.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit linecolor — The color of the line.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

cycle = [:color] — Sets which attributes to cycle when creating multiple plots.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

fxaa = false — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

linecap = @inherit linecap — Sets the type of linecap used, i.e. :butt (flat with no extrusion), :square (flat with 1 linewidth extrusion) or :round.

linestyle = nothing — Sets the pattern of the line e.g. :solid, :dot, :dashdot. For custom patterns look at Linestyle(Number[...])

linewidth = @inherit linewidth — Sets the width of the line in pixel units

lowclip = automatic — The color for any value below the colorrange.

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automatic — No docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

ablines!

ablines! is the mutating variant of plotting function ablines. Check the docstring for ablines for further information.

activate_interaction!

activate_interaction!(parent, name::Symbol)

Activate the interaction named name registered in parent.

addmouseevents!

addmouseevents!(scene, elements...)

Returns a MouseEventHandle with an observable inside which is triggered by all mouse interactions with the scene and optionally restricted to all given plot objects in elements.

To react to mouse events, use the onmouse... handlers.

Example:

mouseevents = addmouseevents!(scene, scatterplot)

onmouseleftclick(mouseevents) do event
    # do something with the mouseevent
end

annotations

annotations(strings::Vector{String}, positions::Vector{Point})

Plots an array of texts at each position in positions.

Plot type

The plot type alias for the annotations function is Annotations.

Attributes

align = (:left, :bottom) — Sets the alignment of the string w.r.t. position. Uses :left, :center, :right, :top, :bottom, :baseline or fractions.

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit textcolor — Sets the color of the text. One can set one color per glyph by passing a Vector{<:Colorant}, or one colorant for the whole text. If color is a vector of numbers, the colormap args are used to map the numbers to colors.

colorrange = automatic — The values representing the start and end points of colormap.

font = @inherit font — Sets the font. Can be a Symbol which will be looked up in the fonts dictionary or a String specifying the (partial) name of a font or the file path of a font file

fonts = @inherit fonts — Used as a dictionary to look up fonts specified by Symbol, for example :regular, :bold or :italic.

fontsize = @inherit fontsize — The fontsize in units depending on markerspace.

fxaa = false — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

justification = automatic — Sets the alignment of text w.r.t its bounding box. Can be :left, :center, :right or a fraction. Will default to the horizontal alignment in align.

lineheight = 1.0 — The lineheight multiplier.

lowclip = automatic — The color for any value below the colorrange.

markerspace = :pixel — Sets the space in which fontsize acts. See Makie.spaces() for possible inputs.

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

offset = (0.0, 0.0) — The offset of the text from the given position in markerspace units.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

position = (0.0, 0.0) — Deprecated: Specifies the position of the text. Use the positional argument to text instead.

rotation = 0.0 — Rotates text around the given position

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

strokecolor = (:black, 0.0) — Sets the color of the outline around a marker.

strokewidth = 0 — Sets the width of the outline around a marker.

text = "" — Specifies one piece of text or a vector of texts to show, where the number has to match the number of positions given. Makie supports String which is used for all normal text and LaTeXString which layouts mathematical expressions using MathTeXEngine.jl.

transform_marker = false — Controls whether the model matrix (without translation) applies to the glyph itself, rather than just the positions. (If this is true, scale! and rotate! will affect the text glyphs.)

transformation = automatic — No docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

word_wrap_width = -1 — Specifies a linewidth limit for text. If a word overflows this limit, a newline is inserted before it. Negative numbers disable word wrapping.

annotations!

annotations! is the mutating variant of plotting function annotations. Check the docstring for annotations for further information.

arc

arc(origin, radius, start_angle, stop_angle; kwargs...)

This function plots a circular arc, centered at origin with radius radius, from start_angle to stop_angle. origin must be a coordinate in 2 dimensions (i.e., a Point2); the rest of the arguments must be <: Number.

Examples:

arc(Point2f(0), 1, 0.0, π)arc(Point2f(1, 2), 0.3, π, -π)

Plot type

The plot type alias for the arc function is Arc.