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:94

@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, 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, 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

lookat::Observable{Vec{3, Float32}}: Focal point of the camera, used for e.g. camera synchronized light direction.

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

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

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, Float32}}
scale::Observable{Vec{3, Float32}}
rotation::Observable{Quaternionf}
model::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 16}}
parent_model::Observable{StaticArraysCore.SMatrix{4, 4, Float32, 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(...))

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:46

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.

All style attributes are the same as for LineSegments.

ablines!

No documentation found.

Makie.ablines! is a Function.

# 1 method for generic function "ablines!" from Makie:
 [1] ablines!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

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.

Attributes

Available attributes and their defaults for Plot{Makie.annotations} are:

  align             (:left, :bottom)
  alpha             1.0
  color             :black
  colormap          :viridis
  colorrange        MakieCore.Automatic()
  colorscale        identity
  depth_shift       0.0f0
  font              :regular
  fonts             Attributes with 4 entries:
  bold => TeX Gyre Heros Makie Bold
  bold_italic => TeX Gyre Heros Makie Bold Italic
  italic => TeX Gyre Heros Makie Italic
  regular => TeX Gyre Heros Makie
  fontsize          14
  highclip          MakieCore.Automatic()
  inspectable       true
  justification     MakieCore.Automatic()
  lineheight        1.0
  lowclip           MakieCore.Automatic()
  markerspace       :pixel
  nan_color         :transparent
  offset            (0.0, 0.0)
  overdraw          false
  position          (0.0, 0.0)
  rotation          0.0
  space             :data
  ssao              false
  strokecolor       (:black, 0.0)
  strokewidth       0
  transform_marker  false
  transparency      false
  visible           true
  word_wrap_width   -1

annotations!

No documentation found.

Makie.annotations! is a Function.

# 1 method for generic function "annotations!" from Makie:
 [1] annotations!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

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, π, -π)

Attributes

Available attributes and their defaults for Plot{Makie.arc} are:

  alpha           1.0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  cycle           [:color]
  depth_shift     0.0f0
  highclip        MakieCore.Automatic()
  inspectable     true
  linestyle       "nothing"
  linewidth       1.5
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  resolution      361
  space           :data
  ssao            false
  transparency    false
  visible         true

arc!

No documentation found.

Makie.arc! is a Function.

# 1 method for generic function "arc!" from Makie:
 [1] arc!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

arrows

arrows(points, directions; kwargs...)
arrows(x, y, u, v)
arrows(x::AbstractVector, y::AbstractVector, u::AbstractMatrix, v::AbstractMatrix)
arrows(x, y, z, u, v, w)
arrows(x, y, [z], f::Function)

Plots arrows at the specified points with the specified components. u and v are interpreted as vector components (u being the x and v being the y), and the vectors are plotted with the tails at x, y.

If x, y, u, v are <: AbstractVector, then each 'row' is plotted as a single vector.

If u, v are <: AbstractMatrix, then x and y are interpreted as specifications for a grid, and u, v are plotted as arrows along the grid.

arrows can also work in three dimensions.

If a Function is provided in place of u, v, [w], then it must accept a Point as input, and return an appropriately dimensioned Point, Vec, or other array-like output.

Attributes

Available attributes and their defaults for Arrows are:

  align           :origin
  alpha           1.0
  arrowcolor      MakieCore.Automatic()
  arrowhead       MakieCore.Automatic()
  arrowsize       MakieCore.Automatic()
  arrowtail       MakieCore.Automatic()
  backlight       0.0f0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  depth_shift     0.0f0
  diffuse         1.0
  highclip        MakieCore.Automatic()
  inspectable     true
  lengthscale     1.0f0
  linecolor       MakieCore.Automatic()
  linestyle       "nothing"
  linewidth       MakieCore.Automatic()
  lowclip         MakieCore.Automatic()
  markerspace     :pixel
  nan_color       :transparent
  normalize       false
  overdraw        false
  quality         32
  shading         MakieCore.Automatic()
  shininess       32.0f0
  space           :data
  specular        0.2
  ssao            false
  transparency    false
  visible         true

arrows!

See arrows.

assetpath

No documentation found.

Makie.assetpath is a Function.

# 1 method for generic function "assetpath" from Makie:
 [1] assetpath(files...)
     @ ~/work/Makie.jl/Makie.jl/src/Makie.jl:106

attributes

No documentation found.

MakieCore.attributes is a Function.

# 2 methods for generic function "attributes" from MakieCore:
 [1] attributes(x::Attributes)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/attributes.jl:34
 [2] attributes(x::AbstractPlot)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/attributes.jl:35

autolimits!

autolimits!()
autolimits!(la::Axis)

Reset manually specified limits of la to an automatically determined rectangle, that depends on the data limits of all plot objects in the axis, as well as the autolimit margins for x and y axis. The argument la defaults to current_axis().

autolimits!(ax::PolarAxis[, unlock_zoom = true])

Calling this tells the PolarAxis to derive limits freely from the plotted data, which allows rmin > 0 and thetalimits spanning less than a full circle. If unlock_zoom = true this also unlocks zooming in r and theta direction and allows for translations in r direction.

available_gradients

available_gradients()

Prints all available gradient names.

available_marker_symbols

available_marker_symbols()

Displays all available marker symbols.

available_plotting_methods

available_plotting_methods()

Returns an array of all available plotting functions.

axis3d

axis3d(args; kw...)

Plots a 3-dimensional OldAxis.

Attributes

OldAxis attributes and their defaults for Plot{Makie.axis3d} are:

    showaxis: (true, true, true)
    visible: true
    ticks: 
        rotation: (-0.7071067811865475 + -0.0im + -0.0jm - 0.7071067811865476km, -4.371139e-8 + 0.0im + 0.0jm + 1.0km, -3.090861907263062e-8 + 3.090861907263061e-8im + 0.7071067811865475jm + 0.7071067811865476km)
        font: (:regular, :regular, :regular)
        ranges_labels: (MakieCore.Automatic(), MakieCore.Automatic())
        formatter: plain
        textcolor: (RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.6f0), RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.6f0), RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.6f0))
        fontsize: (5, 5, 5)
        align: ((:left, :center), (:right, :center), (:right, :center))
        gap: 3
    fonts: 
        bold: TeX Gyre Heros Makie Bold
        italic: TeX Gyre Heros Makie Italic
        bold_italic: TeX Gyre Heros Makie Bold Italic
        regular: TeX Gyre Heros Makie
    names: 
        axisnames: ("x", "y", "z")
        rotation: (-0.7071067811865475 + -0.0im + -0.0jm - 0.7071067811865476km, -4.371139e-8 + 0.0im + 0.0jm + 1.0km, -3.090861907263062e-8 + 3.090861907263061e-8im + 0.7071067811865475jm + 0.7071067811865476km)
        font: (:regular, :regular, :regular)
        textcolor: (:black, :black, :black)
        fontsize: (6.0, 6.0, 6.0)
        align: ((:left, :center), (:right, :center), (:right, :center))
        gap: 3
    scale: Float32[1.0, 1.0, 1.0]
    showgrid: (true, true, true)
    padding: 0.1
    frame: 
        axiscolor: (:black, :black, :black)
        axislinewidth: (1.5, 1.5, 1.5)
        linewidth: (1, 1, 1)
        linecolor: (RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.4f0), RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.4f0), RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.4f0))
    inspectable: false
    showticks: (true, true, true)

axis3d!

No documentation found.

Makie.axis3d! is a Function.

# 3 methods for generic function "axis3d!" from Makie:
 [1] axis3d!(scene::Scene; ...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/axis.jl:345
 [2] axis3d!(scene::Scene, lims; kw...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/axis.jl:345
 [3] axis3d!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

axislegend

axislegend(ax, args...; position = :rt, kwargs...)
axislegend(ax, args...; position = (1, 1), kwargs...)
axislegend(ax = current_axis(); kwargs...)
axislegend(title::AbstractString; kwargs...)
axislegend(ax, title::AbstractString; kwargs...)

Create a legend that sits inside an Axis's plot area.

The position can be a Symbol where the first letter controls the horizontal alignment and can be l, r or c, and the second letter controls the vertical alignment and can be t, b or c. Or it can be a tuple where the first element is set as the Legend's halign and the second element as its valign.

With the keywords merge and unique you can control how plot objects with the same labels are treated. If merge is true, all plot objects with the same label will be layered on top of each other into one legend entry. If unique is true, all plot objects with the same plot type and label will be reduced to one occurrence.

band

band(x, ylower, yupper; kwargs...)
band(lower, upper; kwargs...)
band(x, lowerupper; kwargs...)

Plots a band from ylower to yupper along x. The form band(lower, upper) plots a ruled surface between the points in lower and upper. Both bounds can be passed together as lowerupper, a vector of intervals.

Attributes

Available attributes and their defaults for Plot{Makie.band} are:

  alpha           1.0
  backlight       0.0f0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  cycle           [:color => :patchcolor]
  depth_shift     0.0f0
  diffuse         1.0
  highclip        MakieCore.Automatic()
  inspectable     true
  interpolate     true
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  shading         NoShading
  shininess       32.0f0
  space           :data
  specular        0.2
  ssao            false
  transparency    false
  visible         true

band!

No documentation found.

Makie.band! is a Function.

# 1 method for generic function "band!" from Makie:
 [1] band!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

barplot

barplot(x, y; kwargs...)

Plots a barplot; y defines the height. x and y should be 1 dimensional. Bar width is determined by the attribute width, shrunk by gap in the following way: width -> width * (1 - gap).

Attributes

Available attributes and their defaults for Plot{Makie.barplot} are:

  alpha                  1.0
  bar_labels             "nothing"
  color                  RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
  color_over_background  MakieCore.Automatic()
  color_over_bar         MakieCore.Automatic()
  colormap               :viridis
  colorrange             MakieCore.Automatic()
  colorscale             identity
  cycle                  [:color => :patchcolor]
  direction              :y
  dodge                  MakieCore.Automatic()
  dodge_gap              0.03
  fillto                 MakieCore.Automatic()
  flip_labels_at         Inf
  gap                    0.2
  highclip               MakieCore.Automatic()
  inspectable            true
  label_align            MakieCore.Automatic()
  label_color            :black
  label_font             :regular
  label_formatter        Makie.bar_label_formatter
  label_offset           5
  label_rotation         0.0
  label_size             14
  lowclip                MakieCore.Automatic()
  marker                 GeometryBasics.HyperRectangle
  n_dodge                MakieCore.Automatic()
  nan_color              :transparent
  offset                 0.0
  stack                  MakieCore.Automatic()
  strokecolor            :black
  strokewidth            0
  transparency           false
  visible                true
  width                  MakieCore.Automatic()

barplot!

No documentation found.

Makie.barplot! is a Function.

# 1 method for generic function "barplot!" from Makie:
 [1] barplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

bottom

No documentation found.

Makie.bottom is a Function.

# 1 method for generic function "bottom" from Makie:
 [1] bottom(rect::Rect2)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/geometrybasics_extension.jl:4

boundingbox

No documentation found.

Makie.boundingbox is a Function.

# 6 methods for generic function "boundingbox" from Makie:
 [1] boundingbox(x::Union{Makie.GlyphCollection, AbstractArray{<:Makie.GlyphCollection}}, args...)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:86
 [2] boundingbox(x, exclude)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:6
 [3] boundingbox(x::MakieCore.Text{<:Tuple{var"#s317"} where var"#s317"<:(AbstractArray{<:Makie.GlyphCollection})})
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:103
 [4] boundingbox(x::MakieCore.Text{<:Tuple{var"#s317"} where var"#s317"<:Makie.GlyphCollection})
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:92
 [5] boundingbox(plot::MakieCore.Text)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:114
 [6] boundingbox(x)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/boundingbox.jl:6

boxplot

boxplot(x, y; kwargs...)

Draw a Tukey style boxplot. The boxplot has 3 components:

a crossbar spanning the interquartile (IQR) range with a midline marking the median
an errorbar whose whiskers span range * iqr
points marking outliers, that is, data outside the whiskers

Arguments

x: positions of the categories
y: variables within the boxes

Keywords

weights: vector of statistical weights (length of data). By default, each observation has weight 1.
orientation=:vertical: orientation of box (:vertical or :horizontal)
width=1: width of the box before shrinking
gap=0.2: shrinking factor, width -> width * (1 - gap)
show_notch=false: draw the notch
notchwidth=0.5: multiplier of width for narrowest width of notch
show_median=true: show median as midline
range: multiple of IQR controlling whisker length
whiskerwidth: multiplier of width for width of T's on whiskers, or :match to match width
show_outliers: show outliers as points
dodge: vector of Integer (length of data) of grouping variable to create multiple side-by-side boxes at the same x position
dodge_gap = 0.03: spacing between dodged boxes

boxplot!

No documentation found.

Makie.boxplot! is a Function.

# 1 method for generic function "boxplot!" from Makie:
 [1] boxplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

bracket

bracket(x1, y1, x2, y2; kwargs...)
bracket(x1s, y1s, x2s, y2s; kwargs...)
bracket(point1, point2; kwargs...)
bracket(vec_of_point_tuples; kwargs...)

Draws a bracket between each pair of points (x1, y1) and (x2, y2) with a text label at the midpoint.

By default each label is rotated parallel to the line between the bracket points.

Attributes

Available attributes and their defaults for Plot{Makie.bracket} are:

  align          (:center, :center)
  color          :black
  font           :regular
  fontsize       14
  justification  MakieCore.Automatic()
  linestyle      :solid
  linewidth      1.5
  offset         0
  orientation    :up
  rotation       MakieCore.Automatic()
  style          :curly
  text           ""
  textcolor      :black
  textoffset     MakieCore.Automatic()
  width          15

bracket!

No documentation found.

Makie.bracket! is a Function.

# 1 method for generic function "bracket!" from Makie:
 [1] bracket!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

broadcast_foreach

broadcast_foreach(f, args...)

Like broadcast but for foreach. Doesn't care about shape and treats Tuples && StaticVectors as scalars. This method is meant for broadcasting across attributes that can either have scalar or vector / array form. An example would be a collection of scatter markers that have different sizes but a single color. The length of an attribute is determined with attr_broadcast_length and elements are accessed with attr_broadcast_getindex.

cam2d

Creates a subscene with a pixel camera

cam2d!

cam2d!(scene::SceneLike, kwargs...)

Creates a 2D camera for the given scene. The camera implements zooming by scrolling and translation using mouse drag. It also implements rectangle selections.

Keyword Arguments

zoomspeed = 0.1f0 sets the zoom speed.
zoombutton = true sets a button (combination) which needs to be pressed to enable zooming. By default no button needs to be pressed.
panbutton = Mouse.right sets the button used to translate the camera. This must include a mouse button.
selectionbutton = (Keyboard.space, Mouse.left) sets the button used for rectangle selection. This must include a mouse button.

cam3d!

cam3d!(scene[; kwargs...])

Creates a Camera3D with zoom_shift_lookat = true and fixed_axis = true. For more information, see Camera3D

cam3d_cad!

cam3d_cad!(scene[; kwargs...])

Creates a Camera3D with cad = true, zoom_shift_lookat = false and fixed_axis = false. For more information, see Camera3D

cam_relative!

cam_relative!(scene)

Creates a camera for the given scene which maps the scene area to a 0..1 by 0..1 range. This camera does not feature controls.

camera

No documentation found.

Makie.camera is a Function.

# 3 methods for generic function "camera" from Makie:
 [1] camera(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:495
 [2] camera(scene::Union{AbstractScene, MakieCore.ScenePlot})
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:496
 [3] camera(x)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:494

cameracontrols

No documentation found.

Makie.cameracontrols is a Function.

# 3 methods for generic function "cameracontrols" from Makie:
 [1] cameracontrols(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:499
 [2] cameracontrols(scene::Union{AbstractScene, MakieCore.ScenePlot})
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:500
 [3] cameracontrols(x)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:498

cameracontrols!

No documentation found.

Makie.cameracontrols! is a Function.

# 3 methods for generic function "cameracontrols!" from Makie:
 [1] cameracontrols!(scene::Scene, cam)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:502
 [2] cameracontrols!(scene::Union{AbstractScene, MakieCore.ScenePlot}, cam)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:506
 [3] cameracontrols!(x, cam)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:507

campixel

No documentation found.

Makie.campixel is a Function.

# 1 method for generic function "campixel" from Makie:
 [1] campixel(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:380

campixel!

campixel!(scene; nearclip=-1000f0, farclip=1000f0)

Creates a pixel camera for the given scene. This means that the positional data of a plot will be interpreted in pixel units. This camera does not feature controls.

categorical_colors

categorical_colors(colormaplike, categories::Integer)

Creates categorical colors and tries to match categories. Will error if color scheme doesn't contain enough categories. Will drop the n last colors, if request less colors than contained in scheme.

center!

No documentation found.

Makie.center! is a Function.

# 3 methods for generic function "center!" from Makie:
 [1] center!(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:548
 [2] center!(scene::Scene, padding, exclude)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:548
 [3] center!(scene::Scene, padding)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:548

cgrad

cgrad(colors, [values]; categorical = nothing, scale = nothing, rev = false, alpha = nothing)

Construct a Colorgradient from colors and values.

colors can be a symbol for ColorSchemes.jl ColorSchemes, a ColorScheme, a vector of colors, a ColorGradient or a ColorPalette. If values is an integer, it specifies the numbers of colors chosen equidistantly from the colorscheme specified by colors. Otherwise vectors are accepted. For continuous color gradients values indicate where between 0 and 1 the colors are positioned. For categorical color gradients values indicate where a color ends and where a new one begins between 0 and 1. 0 and 1 are added to values if not already present.

If rev is true colors are reversed. scale accepts the symbols :log, :log10, :log2, :ln, :exp, :exp10 or functions. If alpha is set, it is applied to all colors.

colgap!

colgap!(gl::GridLayout, i::Integer, s::Union{Fixed, Relative, Real})
colgap!(gl::GridLayout, s::Union{Fixed, Relative, Real})

Set the gap between columns in gl. The two-argument version sets all column gaps in gl. The three-argument version sets the gap between columns i and i+1. Passing a real number to s has the same behaviour as passing Fixed(s).

Attributes

Available attributes and their defaults for Plot{Makie.contour} are:

  alpha           1.0
  color           "nothing"
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  depth_shift     0.0f0
  enable_depth    true
  highclip        MakieCore.Automatic()
  inspectable     true
  labelcolor      "nothing"
  labelfont       :regular
  labelformatter  Makie.contour_label_formatter
  labels          false
  labelsize       10
  levels          5
  linestyle       "nothing"
  linewidth       1.0
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  transparency    false
  visible         true

contour!

No documentation found.

Makie.contour! is a Function.

# 1 method for generic function "contour!" from Makie:
 [1] contour!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

contour3d

contour3d(x, y, z)

Creates a 3D contour plot of the plane spanning x::Vector, y::Vector, z::Matrix, with z-elevation for each level.

Attributes

Available attributes and their defaults for Plot{Makie.contour3d} are:

  alpha           1.0
  color           "nothing"
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  depth_shift     0.0f0
  enable_depth    true
  highclip        MakieCore.Automatic()
  inspectable     true
  labelcolor      "nothing"
  labelfont       :regular
  labelformatter  Makie.contour_label_formatter
  labels          false
  labelsize       10
  levels          5
  linestyle       "nothing"
  linewidth       1.0
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  transparency    false
  visible         true

contour3d!

No documentation found.

Makie.contour3d! is a Function.

# 1 method for generic function "contour3d!" from Makie:
 [1] contour3d!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

contourf

contourf(xs, ys, zs; kwargs...)

Plots a filled contour of the height information in zs at horizontal grid positions xs and vertical grid positions ys.

The attribute levels can be either

an Int that produces n equally wide levels or bands
an AbstractVector{<:Real} that lists n consecutive edges from low to high, which result in n-1 levels or bands

You can also set the mode attribute to :relative. In this mode you specify edges by the fraction between minimum and maximum value of zs. This can be used for example to draw bands for the upper 90% while excluding the lower 10% with levels = 0.1:0.1:1.0, mode = :relative.

In :normal mode, if you want to show a band from -Inf to the low edge, set extendlow to :auto for the same color as the first level, or specify a different color (default nothing means no extended band) If you want to show a band from the high edge to Inf, set extendhigh to :auto for the same color as the last level, or specify a different color (default nothing means no extended band).

If levels is an Int, the contour plot will be rectangular as all zs will be covered. This is why Axis defaults to tight limits for such contourf plots. If you specify levels as an AbstractVector{<:Real}, however, note that the axis limits include the default margins because the contourf plot can have an irregular shape. You can use tightlimits!(ax) to tighten the limits similar to the Int behavior.

Attributes

Available attributes and their defaults for Plot{Makie.contourf} are:

  colormap      :viridis
  colorscale    identity
  extendhigh    "nothing"
  extendlow     "nothing"
  inspectable   true
  levels        10
  mode          :normal
  nan_color     :transparent
  transparency  false

contourf!

No documentation found.

Makie.contourf! is a Function.

# 1 method for generic function "contourf!" from Makie:
 [1] contourf!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

convert_arguments

Wrap a single point or equivalent object in a single-element array.

Enables to use scatter like a surface plot with x::Vector, y::Vector, z::Matrix spanning z over the grid spanned by x y

convert_arguments(P, x, y, z)::(Vector)

Takes vectors x, y, and z and turns it into a vector of 3D points of the values from x, y, and z. P is the plot Type (it is optional).

convert_arguments(P, x)::(Vector)

Takes an input GeometryPrimitive x and decomposes it to points. P is the plot Type (it is optional).

convert_arguments(P, y)::Vector

Takes vector y and generates a range from 1 to the length of y, for plotting on an arbitrary x axis.

P is the plot Type (it is optional).

convert_arguments(P, x, y)::(Vector)

Takes vectors x and y and turns it into a vector of 2D points of the values from x and y.

P is the plot Type (it is optional).

convert_arguments(P, x)::(Vector)

Takes an input Rectx and decomposes it to points.

P is the plot Type (it is optional).

convert_arguments(PB, LineString)

Takes an input LineString and decomposes it to points.

convert_arguments(PB, Union{Array{<:LineString}, MultiLineString})

Takes an input Array{LineString} or a MultiLineString and decomposes it to points.

convert_arguments(PB, Polygon)

Takes an input Polygon and decomposes it to points.

convert_arguments(PB, Union{Array{<:Polygon}, MultiPolygon})

Takes an input Array{Polygon} or a MultiPolygon and decomposes it to points.

convert_arguments(ct::GridBased, x::VecOrMat, y::VecOrMat, z::Matrix)

If ct is Heatmap and x and y are vectors, infer from length of x and y whether they represent edges or centers of the heatmap bins. If they are centers, convert to edges. Convert eltypes to Float32 and return outputs as a Tuple.

convert_arguments(P, x::RangeLike, y::RangeLike, z::AbstractMatrix)

Takes one or two ClosedIntervals x and y and converts them to closed ranges with size(z, 1/2).

convert_arguments(::ImageLike, mat::AbstractMatrix)

Generates ClosedIntervals of size 0 .. size(mat, 1/2) as x and y values.

convert_arguments(P, x, y, f)::(Vector, Vector, Matrix)

Takes vectors x and y and the function f, and applies f on the grid that x and y span. This is equivalent to f.(x, y'). P is the plot Type (it is optional).

convert_arguments(P, Matrix)::Tuple{ClosedInterval, ClosedInterval, ClosedInterval, Matrix}

Takes an array of {T, 3} where T, converts the dimensions n, m and k into ClosedInterval, and stores the ClosedInterval to n, m and k, plus the original array in a Tuple.

P is the plot Type (it is optional).

convert_arguments(P, x, y, z, i)::(Vector, Vector, Vector, Matrix)

Takes 3 AbstractVectorx, y, and z and the AbstractMatrixi, and puts everything in a Tuple.

P is the plot Type (it is optional).

Accepts a Vector of Pair of Points (e.g. [Point(0, 0) => Point(1, 1), ...]) to encode e.g. linesegments or directions.

convert_arguments(Mesh, x, y, z)::GLNormalMesh

Takes real vectors x, y, z and constructs a mesh out of those, under the assumption that every 3 points form a triangle.

convert_arguments(Mesh, xyz::AbstractVector)::GLNormalMesh

Takes an input mesh and a vector xyz representing the vertices of the mesh, and creates indices under the assumption, that each triplet in xyz forms a triangle.

convert_arguments(Mesh, x, y, z, indices)::GLNormalMesh

Takes real vectors x, y, z and constructs a triangle mesh out of those, using the faces in indices, which can be integers (every 3 -> one triangle), or GeometryBasics.NgonFace{N, <: Integer}.

convert_arguments(Mesh, vertices, indices)::GLNormalMesh

Takes vertices and indices, and creates a triangle mesh out of those. See to_vertices and to_triangles for more information about accepted types.

convert_arguments(P, x, y, z, f)::(Vector, Vector, Vector, Matrix)

Takes AbstractVectorx, y, and z and the function f, evaluates f on the volume spanned by x, y and z, and puts x, y, z and f(x,y,z) in a Tuple.

P is the plot Type (it is optional).

convert_attribute

convert_attribute(value, attribute::Key[, plottype::Key])

Convert value into a suitable domain for use as attribute.

Example

julia> using Makie

julia> Makie.convert_attribute(:black, key"color"())
RGBA{Float32}(0.0f0,0.0f0,0.0f0,1.0f0)

crossbar

crossbar(x, y, ymin, ymax; kwargs...)

Draw a crossbar. A crossbar represents a range with a (potentially notched) box. It is most commonly used as part of the boxplot.

Arguments

x: position of the box
y: position of the midline within the box
ymin: lower limit of the box
ymax: upper limit of the box

Keywords

orientation=:vertical: orientation of box (:vertical or :horizontal)
width=1: width of the box before shrinking
gap=0.2: shrinking factor, width -> width * (1 - gap)
show_notch=false: draw the notch
notchmin=automatic: lower limit of the notch
notchmax=automatic: upper limit of the notch
notchwidth=0.5: multiplier of width for narrowest width of notch
show_midline=true: show midline

crossbar!

No documentation found.

Makie.crossbar! is a Function.

# 1 method for generic function "crossbar!" from Makie:
 [1] crossbar!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

current_axis

current_axis()

Returns the current active axis (or the last axis created). Returns nothing if there is no current active axis.

current_axis!

current_axis!(fig::Figure, ax)

Set ax as the current active axis in fig.

current_axis!(ax)

Set an axis ax, which must be part of a figure, as the figure's current active axis.

current_figure

current_figure()

Returns the current active figure (or the last figure created). Returns nothing if there is no current active figure.

current_figure!

current_figure!(fig)

Set fig as the current active figure.

data_limits

No documentation found.

Makie.data_limits is a Function.

# 19 methods for generic function "data_limits" from Makie:
  [1] data_limits(hb::Plot{Makie.hexbin})
     @ ~/work/Makie.jl/Makie.jl/src/stats/hexbin.jl:65
  [2] data_limits(plot::MeshScatter)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:253
  [3] data_limits(plot::Image)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:246
  [4] data_limits(plot::Heatmap)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:239
  [5] data_limits(plot::Surface)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:232
  [6] data_limits(text::MakieCore.Text{<:Tuple{var"#s317"} where var"#s317"<:Union{Makie.GlyphCollection, AbstractVector{Makie.GlyphCollection}}})
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:43
  [7] data_limits(text::MakieCore.Text)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:56
  [8] data_limits(p::Plot{Makie.voronoiplot, <:Tuple{var"#s317"} where var"#s317"<:(Vector{<:Point{N}})}) where N
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/voronoiplot.jl:170
  [9] data_limits(p::Plot{Makie.triplot, <:Tuple{var"#s317"} where var"#s317"<:(Vector{<:Point})})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/triplot.jl:244
 [10] data_limits(p::Plot{Makie.vspan})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvspan.jl:107
 [11] data_limits(p::Plot{Makie.hspan})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvspan.jl:97
 [12] data_limits(p::Plot{Makie.vlines})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvlines.jl:100
 [13] data_limits(p::Plot{Makie.hlines})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvlines.jl:91
 [14] data_limits(bars::Union{Plot{Makie.errorbars}, Plot{Makie.rangebars}})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/error_and_rangebars.jl:296
 [15] data_limits(p::Plot{Makie.datashader})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/datashader.jl:469
 [16] data_limits(pl::Plot{Makie.bracket})
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/bracket.jl:114
 [17] data_limits(plot::AbstractPlot)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:170
 [18] data_limits(scenelike, exclude)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:221
 [19] data_limits(scenelike)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/data_limits.jl:221

datashader

datashader(points::AbstractVector{<: Point})

Warning

This feature might change outside breaking releases, since the API is not yet finalized. Please be vary of bugs in the implementation and open issues if you encounter odd behaviour.

Points can be any array type supporting iteration & getindex, including memory mapped arrays. If you have separate arrays for x and y coordinates and want to avoid conversion and copy, consider using:

using Makie.StructArrays
points = StructArray{Point2f}((x, y))
datashader(points)

Do pay attention though, that if x and y don't have a fast iteration/getindex implemented, this might be slower then just copying it into a new array.

For best performance, use method=Makie.AggThreads() and make sure to start julia with julia -tauto or have the environment variable JULIA_NUM_THREADS set to the number of cores you have.

Attributes

Specific to `DataShader`

agg = AggCount() can be AggCount(), AggAny() or AggMean(). User extendable by overloading:

```Julia
    struct MyAgg{T} <: Makie.AggOp end
    MyAgg() = MyAgg{Float64}()
    Makie.Aggregation.null(::MyAgg{T}) where {T} = zero(T)
    Makie.Aggregation.embed(::MyAgg{T}, x) where {T} = convert(T, x)
    Makie.Aggregation.merge(::MyAgg{T}, x::T, y::T) where {T} = x + y
    Makie.Aggregation.value(::MyAgg{T}, x::T) where {T} = x
```

method = AggThreads() can be AggThreads() or AggSerial().
async::Bool = true will calculate get_aggregation in a task, and skip any zoom/pan updates while busy. Great for interaction, but must be disabled for saving to e.g. png or when inlining in documenter.
operation::Function = automatic Defaults to Makie.equalize_histogram function which gets called on the whole getaggregation array before display (`operation(finalaggregation_result)`).
local_operation::Function = identity function which gets call on each element after the aggregation (map!(x-> local_operation(x), final_aggregation_result)).
point_transform::Function = identity function which gets applied to every point before aggregating it.
binsize::Number = 1 factor defining how many bins one wants per screen pixel. Set to n > 1 if you want a corser image.
show_timings::Bool = false show how long it takes to aggregate each frame.
interpolate::Bool = true If the resulting image should be displayed interpolated.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

datashader!

No documentation found.

Makie.datashader! is a Function.

# 1 method for generic function "datashader!" from Makie:
 [1] datashader!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

deactivate_interaction!

deactivate_interaction!(parent, name::Symbol)

Deactivate the interaction named name registered in parent. It can be reactivated with activate_interaction!.

decompose

decompose(facetype, contour::AbstractArray{<:AbstractPoint})

Triangulate a Polygon without hole.

Returns a Vector{facetype} defining indexes into contour.

default_theme

No documentation found.

MakieCore.default_theme is a Function.

# 60 methods for generic function "default_theme" from MakieCore:
  [1] default_theme(scene, ::Type{<:Plot{Main.FD_SANDBOX_12283929528957551597.stockchart}})
     @ Main.FD_SANDBOX_12283929528957551597 ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [2] default_theme(scene, ::Type{<:Plot{RPRMakie.matball}})
     @ RPRMakie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [3] default_theme(scene, ::Type{<:Plot{Makie.ablines}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [4] default_theme(scene, ::Type{<:Plot{Makie.annotations}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [5] default_theme(scene, ::Type{<:Plot{Makie.arc}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [6] default_theme(scene, ::Type{<:Plot{Makie.axis3d}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [7] default_theme(scene, ::Type{<:Plot{Makie.band}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [8] default_theme(scene, ::Type{<:Plot{Makie.barplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
  [9] default_theme(scene, ::Type{<:Plot{Makie.bracket}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [10] default_theme(scene, ::Type{<:Plot{Makie.contour}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [11] default_theme(scene, ::Type{<:Plot{Makie.contour3d}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [12] default_theme(scene, ::Type{<:Plot{Makie.contourf}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [13] default_theme(scene, ::Type{<:Plot{Makie.datashader}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [14] default_theme(scene, ::Type{<:Plot{Makie.errorbars}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [15] default_theme(scene, ::Type{<:Plot{Makie.rangebars}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [16] default_theme(scene, ::Type{<:Plot{Makie.hlines}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [17] default_theme(scene, ::Type{<:Plot{Makie.vlines}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [18] default_theme(scene, ::Type{<:Plot{Makie.hspan}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [19] default_theme(scene, ::Type{<:Plot{Makie.vspan}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [20] default_theme(scene, ::Type{<:Plot{Makie.pie}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [21] default_theme(scene, ::Type{<:Plot{Makie.scatterlines}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [22] default_theme(scene, ::Type{<:Plot{Makie.spy}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [23] default_theme(scene, ::Type{<:Plot{Makie.stairs}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [24] default_theme(scene, ::Type{<:Plot{Makie.stem}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [25] default_theme(scene, ::Type{<:Plot{Makie.streamplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [26] default_theme(scene, ::Type{<:Plot{Makie.timeseries}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [27] default_theme(scene, ::Type{<:Plot{Makie.tricontourf}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [28] default_theme(scene, ::Type{<:Plot{Makie.triplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [29] default_theme(scene, ::Type{<:Plot{Makie.volumeslices}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [30] default_theme(scene, ::Type{<:Plot{Makie.voronoiplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [31] default_theme(scene, ::Type{<:Plot{Makie.waterfall}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [32] default_theme(scene, ::Type{<:Plot{Makie.tooltip}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [33] default_theme(scene, ::Type{<:Plot{Makie.plotlist}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [34] default_theme(scene, ::Type{<:Plot{Makie.stephist}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [35] default_theme(scene, ::Type{<:Plot{Makie.hist}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [36] default_theme(scene, ::Type{<:Plot{Makie.density}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [37] default_theme(scene, ::Type{<:Plot{Makie.ecdfplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [38] default_theme(scene, ::Type{<:Plot{Makie.qqplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [39] default_theme(scene, ::Type{<:Plot{Makie.qqnorm}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [40] default_theme(scene, ::Type{<:Plot{Makie.crossbar}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [41] default_theme(scene, ::Type{<:Plot{Makie.boxplot}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [42] default_theme(scene, ::Type{<:Plot{Makie.violin}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [43] default_theme(scene, ::Type{<:Plot{Makie.hexbin}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [44] default_theme(scene, ::Type{<:Plot{Makie.series}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [45] default_theme(scene, ::Type{<:Plot{Makie.rainclouds}})
     @ Makie ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [46] default_theme(scene, ::Type{<:Arrows})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [47] default_theme(scene, ::Type{<:Wireframe})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [48] default_theme(scene, ::Type{<:Poly})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [49] default_theme(scene, ::Type{<:MakieCore.Text})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [50] default_theme(scene, ::Type{<:MeshScatter})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [51] default_theme(scene, ::Type{<:Scatter})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [52] default_theme(scene, ::Type{<:Image})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [53] default_theme(scene, ::Type{<:Heatmap})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [54] default_theme(scene, ::Type{<:Volume})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [55] default_theme(scene, ::Type{<:Surface})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [56] default_theme(scene, ::Type{<:Lines})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [57] default_theme(scene, ::Type{<:LineSegments})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [58] default_theme(scene, ::Type{<:Mesh})
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:177
 [59] default_theme(scene)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/basic_plots.jl:1
 [60] default_theme(scene, T)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:62

density

density(values; npoints = 200, offset = 0.0, direction = :x)

Plot a kernel density estimate of values. npoints controls the resolution of the estimate, the baseline can be shifted with offset and the direction set to :x or :y. bandwidth and boundary are determined automatically by default.

Statistical weights can be provided via the weights keyword argument.

color is usually set to a single color, but can also be set to :x or :y to color with a gradient. If you use :y when direction = :x (or vice versa), note that only 2-element colormaps can work correctly.

Attributes

Available attributes and their defaults for Plot{Makie.density} are:

  bandwidth     MakieCore.Automatic()
  boundary      MakieCore.Automatic()
  color         RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
  colormap      :viridis
  colorrange    MakieCore.Automatic()
  colorscale    identity
  cycle         [:color => :patchcolor]
  direction     :x
  inspectable   true
  linestyle     "nothing"
  npoints       200
  offset        0.0
  strokearound  false
  strokecolor   :black
  strokewidth   0
  weights       MakieCore.Automatic()

density!

No documentation found.

Makie.density! is a Function.

# 1 method for generic function "density!" from Makie:
 [1] density!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

deregister_interaction!

deregister_interaction!(parent, name::Symbol)

Deregister the interaction named name registered in parent.

disconnect!

No documentation found.

Makie.disconnect! is a Function.

# 16 methods for generic function "disconnect!" from Makie:
  [1] disconnect!(window::GLFW.Window, ::typeof(unicode_input))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:167
  [2] disconnect!(window::GLFW.Window, ::typeof(hasfocus))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:272
  [3] disconnect!(window::GLFW.Window, ::typeof(mouse_position))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:218
  [4] disconnect!(::GLFW.Window, ::typeof(window_area))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:86
  [5] disconnect!(window::GLFW.Window, ::typeof(mouse_buttons))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:108
  [6] disconnect!(window::GLFW.Window, ::typeof(scroll))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:249
  [7] disconnect!(window::GLFW.Window, ::typeof(entered_window))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:294
  [8] disconnect!(window::GLFW.Window, ::typeof(dropped_files))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:144
  [9] disconnect!(window::GLFW.Window, ::typeof(keyboard_buttons))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:123
 [10] disconnect!(window::GLFW.Window, ::typeof(window_open))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:36
 [11] disconnect!(c::Camera)
     @ ~/work/Makie.jl/Makie.jl/src/camera/camera.jl:25
 [12] disconnect!(c::EmptyCamera)
     @ ~/work/Makie.jl/Makie.jl/src/camera/camera.jl:33
 [13] disconnect!(observables::Vector)
     @ ~/work/Makie.jl/Makie.jl/src/camera/camera.jl:37
 [14] disconnect!(screen::GLMakie.Screen, ::typeof(window_area))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:80
 [15] disconnect!(screen::GLMakie.Screen, ::typeof(mouse_position))
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:214
 [16] disconnect!(window::MakieScreen, signal)
     @ ~/work/Makie.jl/Makie.jl/src/interaction/events.jl:35

dropped_files

Registers a callback for drag and drop of files. returns Observable{Vector{String}}, which are absolute file paths GLFW Docs

ecdfplot

ecdfplot(values; npoints=10_000[, weights])

Plot the empirical cumulative distribution function (ECDF) of values.

npoints controls the resolution of the plot. If weights for the values are provided, a weighted ECDF is plotted.

Attributes

Available attributes and their defaults for Plot{Makie.ecdfplot} are:

  alpha           1.0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  cycle           [:color]
  depth_shift     0.0f0
  highclip        MakieCore.Automatic()
  inspectable     true
  linestyle       "nothing"
  linewidth       1.5
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  step            :pre
  transparency    false
  visible         true

ecdfplot!

No documentation found.

Makie.ecdfplot! is a Function.

# 1 method for generic function "ecdfplot!" from Makie:
 [1] ecdfplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

entered_window

Registers a callback for if the mouse has entered the window. returns an Observable{Bool}, which is true whenever the cursor enters the window. GLFW Docs

errorbars

errorbars(x, y, error_both; kwargs...)
errorbars(x, y, error_low, error_high; kwargs...)
errorbars(x, y, error_low_high; kwargs...)

errorbars(xy, error_both; kwargs...)
errorbars(xy, error_low, error_high; kwargs...)
errorbars(xy, error_low_high; kwargs...)

errorbars(xy_error_both; kwargs...)
errorbars(xy_error_low_high; kwargs...)

Plots errorbars at xy positions, extending by errors in the given direction.

If you want to plot intervals from low to high values instead of relative errors, use rangebars.

Attributes

Available attributes and their defaults for Plot{Makie.errorbars} are:

  color         :black
  colormap      :viridis
  colorrange    MakieCore.Automatic()
  colorscale    identity
  cycle         [:color]
  direction     :y
  inspectable   true
  linewidth     1.5
  transparency  false
  visible       true
  whiskerwidth  0

errorbars!

No documentation found.

Makie.errorbars! is a Function.

# 1 method for generic function "errorbars!" from Makie:
 [1] errorbars!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

events

No documentation found.

Makie.events is a Function.

# 3 methods for generic function "events" from Makie:
 [1] events(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:491
 [2] events(scene::Union{AbstractScene, MakieCore.ScenePlot})
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:492
 [3] events(x)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:490

fill_between!

fill_between!(scenelike, x, y1, y2; where = nothing, kw_args...)

fill the section between 2 lines with the condition where

grid!

grid!(content::Vararg{Pair}; kwargs...)

Creates a GridLayout with all pairs contained in content. Each pair consists of an iterable with row and column spans, and a content object. Each content object is then placed in the GridLayout at the span from its pair.

Example:

grid!( [1, 1] => obj1, [1, 2] => obj2, [2, :] => obj3, )

grid!(content::AbstractMatrix; kwargs...)

Creates a GridLayout filled with matrix-like content. The size of the grid will be the size of the matrix.

gridnest!

No documentation found.

GridLayoutBase.gridnest! is a Function.

# 1 method for generic function "gridnest!" from GridLayoutBase:
 [1] gridnest!(gl::GridLayout, rows::Union{Colon, Int64, UnitRange}, cols::Union{Colon, Int64, UnitRange})
     @ ~/.julia/packages/GridLayoutBase/Ld41D/src/gridlayout.jl:594

hasfocus

Registers a callback for the focus of a window. returns an Observable{Bool}, which is true whenever the window has focus. GLFW Docs

heatmap

heatmap(x, y, matrix)
heatmap(x, y, func)
heatmap(matrix)
heatmap(xvector, yvector, zvector)

Plots a heatmap as a collection of rectangles. x and y can either be of length i and j where (i, j) is size(matrix), in this case the rectangles will be placed around these grid points like voronoi cells. Note that for irregularly spaced x and y, the points specified by them are not centered within the resulting rectangles.

x and y can also be of length i+1 and j+1, in this case they are interpreted as the edges of the rectangles.

Colors of the rectangles are derived from matrix[i, j]. The third argument may also be a Function (i, j) -> v which is then evaluated over the grid spanned by x and y.

Another allowed form is using three vectors xvector, yvector and zvector. In this case it is assumed that no pair of elements x and y exists twice. Pairs that are missing from the resulting grid will be treated as if zvector had a NaN element at that position.

If x and y are omitted with a matrix argument, they default to x, y = axes(matrix).

Note that heatmap is slower to render than image so image should be preferred for large, regularly spaced grids.

Attributes

Specific to `Heatmap`

interpolate::Bool = false sets whether colors should be interpolated.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

heatmap!

No documentation found.

MakieCore.heatmap! is a Function.

# 1 method for generic function "heatmap!" from MakieCore:
 [1] heatmap!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

height

No documentation found.

GeometryBasics.height is a Function.

# 2 methods for generic function "height" from GeometryBasics:
 [1] height(c::GeometryBasics.Cylinder{N, T}) where {N, T}
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/primitives/cylinders.jl:26
 [2] height(prim::GeometryBasics.HyperRectangle)
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/primitives/rectangles.jl:187

help

help(func[; extended = false])

Welcome to the main help function of Makie.jl / Makie.jl.

For help on a specific function's arguments, type help_arguments(function_name).

For help on a specific function's attributes, type help_attributes(plot_Type).

Use the optional extended = true keyword argument to see more details.

help_arguments

help_arguments([io], func)

Returns a list of signatures for function func.

help_attributes

help_attributes([io], Union{PlotType, PlotFunction}; extended = false)

Returns a list of attributes for the plot type Typ. The attributes returned extend those attributes found in the default_theme.

Use the optional keyword argument extended (default = false) to show in addition the default values of each attribute. usage:

>help_attributes(scatter)
    alpha
    color
    colormap
    colorrange
    distancefield
    glowcolor
    glowwidth
    linewidth
    marker
    marker_offset
    markersize
    overdraw
    rotations
    strokecolor
    strokewidth
    transform_marker
    transparency
    uv_offset_width
    visible

hexbin

hexbin(xs, ys; kwargs...)

Plots a heatmap with hexagonal bins for the observations xs and ys.

Attributes

Specific to `Hexbin`

weights = nothing: Weights for each observation. Can be nothing (each observation carries weight 1) or any AbstractVector{<: Real} or StatsBase.AbstractWeights.
bins = 20: If an Int, sets the number of bins in x and y direction. If a Tuple{Int, Int}, sets the number of bins for x and y separately.
cellsize = nothing: If a Real, makes equally-sided hexagons with width cellsize. If a Tuple{Real, Real} specifies hexagon width and height separately.
threshold::Int = 1: The minimal number of observations in the bin to be shown. If 0, all zero-count hexagons fitting into the data limits will be shown.
colorscale = identity: A function to scale the number of observations in a bin, eg. log10.

Generic

colormap::Union{Symbol, Vector{<:Colorant}} = :viridis
colorrange::Tuple(<:Real,<:Real} = Makie.automatic sets the values representing the start and end points of colormap.

hexbin!

No documentation found.

Makie.hexbin! is a Function.

# 1 method for generic function "hexbin!" from Makie:
 [1] hexbin!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

hgrid!

hbox!(content::Vararg; kwargs...)

Creates a single-row GridLayout with all elements contained in content placed from left to right.

hidedecorations!

hidedecorations!(la::Axis; label = true, ticklabels = true, ticks = true,
                 grid = true, minorgrid = true, minorticks = true)

Hide decorations of both x and y-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

See also [hidexdecorations!], [hideydecorations!], [hidezdecorations!]

hidedecorations!(ax::PolarAxis; ticklabels = true, grid = true, minorgrid = true)

Hide decorations of both r and theta-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

See also [hiderdecorations!], [hidethetadecorations!], [hidezdecorations!]

hiderdecorations!

hiderdecorations!(ax::PolarAxis; ticklabels = true, grid = true, minorgrid = true)

Hide decorations of the r-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

hidespines!

hidespines!(la::Axis, spines::Symbol... = (:l, :r, :b, :t)...)

Hide all specified axis spines. Hides all spines by default, otherwise choose which sides to hide with the symbols :l (left), :r (right), :b (bottom) and :t (top).

hidethetadecorations!

hidethetadecorations!(ax::PolarAxis; ticklabels = true, grid = true, minorgrid = true)

Hide decorations of the theta-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

hidexdecorations!

hidexdecorations!(la::Axis; label = true, ticklabels = true, ticks = true, grid = true,
    minorgrid = true, minorticks = true)

Hide decorations of the x-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

hideydecorations!

hideydecorations!(la::Axis; label = true, ticklabels = true, ticks = true, grid = true,
    minorgrid = true, minorticks = true)

Hide decorations of the y-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

hidezdecorations!

hidezdecorations!(ax::Axis3; label = true, ticklabels = true, ticks = true, grid = true)

Hide decorations of the z-axis: label, ticklabels, ticks and grid. Keyword arguments can be used to disable hiding of certain types of decorations.

hist

hist(values; bins = 15, normalization = :none)

Plot a histogram of values. bins can be an Int to create that number of equal-width bins over the range of values. Alternatively, it can be a sorted iterable of bin edges. The histogram can be normalized by setting normalization. Possible values are:

:pdf: Normalize by sum of weights and bin sizes. Resulting histogram has norm 1 and represents a PDF.
:density: Normalize by bin sizes only. Resulting histogram represents count density of input and does not have norm 1. Will not modify the histogram if it already represents a density (h.isdensity == 1).
:probability: Normalize by sum of weights only. Resulting histogram represents the fraction of probability mass for each bin and does not have norm 1.
:none: Do not normalize.

Statistical weights can be provided via the weights keyword argument.

The following attributes can move the histogram around, which comes in handy when placing multiple histograms into one plot:

offset = 0.0: adds an offset to every value
fillto = 0.0: defines where the bar starts
scale_to = nothing: allows to scale all values to a certain height. This

can also be set to :flip to flip the direction of histogram bars without scaling them to a common height.

Color can either be:

a vector of bins colors
a single color
:values, to color the bars with the values from the histogram

You can also draw a histogram in x-direction rather than y-direction by setting direction = :x.

Attributes

Available attributes and their defaults for Plot{Makie.hist} are:

  bar_labels             "nothing"
  bins                   15
  color                  RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
  cycle                  [:color => :patchcolor]
  fillto                 MakieCore.Automatic()
  flip_labels_at         Inf
  label_color            :black
  label_font             :regular
  label_formatter        Makie.bar_label_formatter
  label_offset           5
  label_size             20
  normalization          :none
  offset                 0.0
  over_background_color  MakieCore.Automatic()
  over_bar_color         MakieCore.Automatic()
  scale_to               "nothing"
  weights                MakieCore.Automatic()

hist!

No documentation found.

Makie.hist! is a Function.

# 1 method for generic function "hist!" from Makie:
 [1] hist!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

hlines

hlines(ys; xmin = 0.0, xmax = 1.0, attrs...)

Create horizontal lines across a Scene with 2D projection. The lines will be placed at ys in data coordinates and xmin to xmax in scene coordinates (0 to 1). All three of these can have single or multiple values because they are broadcast to calculate the final line segments.

All style attributes are the same as for LineSegments.

hlines!

No documentation found.

Makie.hlines! is a Function.

# 1 method for generic function "hlines!" from Makie:
 [1] hlines!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

hovered_scene

hovered_scene()

Returns the scene that the mouse is currently hovering over.

Properly identifies the scene for a plot with multiple sub-plots.

hspan

hspan(ys_low, ys_high; xmin = 0.0, xmax = 1.0, attrs...)
hspan(ys_lowhigh; xmin = 0.0, xmax = 1.0, attrs...)

Create horizontal bands spanning across a Scene with 2D projection. The bands will be placed from ys_low to ys_high in data coordinates and xmin to xmax in scene coordinates (0 to 1). All four of these can have single or multiple values because they are broadcast to calculate the final spans. Both bounds can be passed together as an interval ys_lowhigh.

All style attributes are the same as for Poly.

hspan!

No documentation found.

Makie.hspan! is a Function.

# 1 method for generic function "hspan!" from Makie:
 [1] hspan!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

image

image(x, y, image)
image(image)

Plots an image on a rectangle bounded by x and y (defaults to size of image).

Attributes

Specific to `Image`

interpolate::Bool = true sets whether colors should be interpolated.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

image!

No documentation found.

MakieCore.image! is a Function.

# 1 method for generic function "image!" from MakieCore:
 [1] image!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

insertplots!

No documentation found.

Makie.insertplots! is a Function.

# 2 methods for generic function "insertplots!" from Makie:
 [1] insertplots!(screen::GLMakie.Screen, scene::Scene)
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/screen.jl:462
 [2] insertplots!(screen::AbstractDisplay, scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:534

interactions

No documentation found.

Makie.interactions is a Function.

# 2 methods for generic function "interactions" from Makie:
 [1] interactions(ax3::Axis3)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/interactions.jl:5
 [2] interactions(ax::Axis)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/interactions.jl:4

is_mouseinside

is_mouseinside(scene)

Returns true if the current mouseposition is inside the given scene.

ispressed

ispressed(parent, result::Bool[, waspressed = nothing]) ispressed(parent, button::Union{Mouse.Button, Keyboard.Button[, waspressed = nothing]) ispressed(parent, collection::Union{Set, Vector, Tuple}[, waspressed = nothing]) ispressed(parent, op::BooleanOperator[, waspressed = nothing])

This function checks if a button or combination of buttons is pressed.

If given a true or false, ispressed will return true or false respectively. This provides a way to turn an interaction "always on" or "always off" from the outside.

Passing a button or collection of buttons such as Keyboard.enter or Mouse.left will return true if all of the given buttons are pressed.

Parent can be any object that has get_scene method implemented, which includes e.g. Figure, Axis, Axis3, Lscene, FigureAxisPlot, and AxisPlot.

For more complicated combinations of buttons they can be combined into boolean expression with &, | and !. For example, you can have ispressed(parent, !Keyboard.left_control & Keyboard.c)) and ispressed(parent, Keyboard.left_control & Keyboard.c) to avoid triggering both cases at the same time.

Furthermore you can also make any button, button collection or boolean expression exclusive by wrapping it in Exclusively(...). With that ispressed will only return true if the currently pressed buttons match the request exactly.

For cases where you want to react to a release event you can optionally add a key or mousebutton waspressed which is then assumed to be pressed regardless of it's current state. For example, when reacting to a mousebutton event, you can pass event.button so that a key combination including that button still evaluates as true.

keyboard_buttons

No documentation found.

Makie.keyboard_buttons is a Function.

# 3 methods for generic function "keyboard_buttons" from Makie:
 [1] keyboard_buttons(scene::Scene, window::GLFW.Window)
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:112
 [2] keyboard_buttons(scene::Scene, screen)
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:111
 [3] keyboard_buttons(scene, native_window)
     @ ~/work/Makie.jl/Makie.jl/src/interaction/events.jl:8

labelslider!

labelslider!(scene, label, range; format = string, sliderkw = Dict(),
labelkw = Dict(), valuekw = Dict(), value_column_width = automatic, layoutkw...)

labelslider! is deprecated, use SliderGrid instead

Construct a horizontal GridLayout with a label, a slider and a value label in scene.

Returns a NamedTuple:

(slider = slider, label = label, valuelabel = valuelabel, layout = layout)

Specify a format function for the value label with the format keyword or pass a format string used by Format.format. The slider is forwarded the keywords from sliderkw. The label is forwarded the keywords from labelkw. The value label is forwarded the keywords from valuekw. You can set the column width for the value label column with the keyword value_column_width. By default, the width is determined heuristically by sampling a few values from the slider range. All other keywords are forwarded to the GridLayout.

Example:

ls = labelslider!(scene, "Voltage:", 0:10; format = x -> "$(x)V")
layout[1, 1] = ls.layout

labelslidergrid!

labelslidergrid!(scene, labels, ranges; formats = [string],
    sliderkw = Dict(), labelkw = Dict(), valuekw = Dict(),
    value_column_width = automatic, layoutkw...)

labelslidergrid! is deprecated, use SliderGrid instead

Construct a GridLayout with a column of label, a column of sliders and a column of value labels in scene. The argument values are broadcast, so you can use scalars if you want to keep labels, ranges or formats constant across rows.

Returns a NamedTuple:

(sliders = sliders, labels = labels, valuelabels = valuelabels, layout = layout)

Specify format functions for the value labels with the formats keyword or pass format strings used by Format.format. The sliders are forwarded the keywords from sliderkw. The labels are forwarded the keywords from labelkw. The value labels are forwarded the keywords from valuekw. You can set the column width for the value label column with the keyword value_column_width. By default, the width is determined heuristically by sampling a few values from the slider ranges. All other keywords are forwarded to the GridLayout.

Example:

ls = labelslidergrid!(scene, ["Voltage", "Ampere"], Ref(0:0.1:100); format = x -> "$(x)V")
layout[1, 1] = ls.layout

left

No documentation found.

Makie.left is a Function.

# 1 method for generic function "left" from Makie:
 [1] left(rect::Rect2)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/geometrybasics_extension.jl:2

lift

map(f, c...) -> collection

Transform collection c by applying f to each element. For multiple collection arguments, apply f elementwise, and stop when any of them is exhausted.

Examples

julia> map(x -> x * 2, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33

map(f, A::AbstractArray...) -> N-array

When acting on multi-dimensional arrays of the same ndims, they must all have the same axes, and the answer will too.

See also broadcast, which allows mismatched sizes.

Examples

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # iterates until 3rd is exhausted
3-element Vector{Float64}:
   2.0
  13.0
 102.0

obs = map(f, arg1::AbstractObservable, args...; ignore_equal_values=false)

Creates a new observable obs which contains the result of f applied to values extracted from arg1 and args (i.e., f(arg1[], ...). arg1 must be an observable for dispatch reasons. args may contain any number of Observable objects. f will be passed the values contained in the observables as the respective argument. All other objects in args are passed as-is.

If you don't need the value of obs, and just want to run f whenever the arguments update, use on or onany instead.

Example

julia> obs = Observable([1,2,3]);

julia> map(length, obs)
Observable(3)

limits!

limits!(ax::Axis, xlims, ylims)

Set the axis limits to xlims and ylims. If limits are ordered high-low, this reverses the axis orientation.

limits!(ax::Axis, x1, x2, y1, y2)

Set the axis x-limits to x1 and x2 and the y-limits to y1 and y2. If limits are ordered high-low, this reverses the axis orientation.

limits!(ax::Axis, rect::Rect2)

Set the axis limits to rect. If limits are ordered high-low, this reverses the axis orientation.

limits!(ax::Axis3, xlims, ylims, zlims)

Set the axis limits to xlims, ylims, and zlims. If limits are ordered high-low, this reverses the axis orientation.

limits!(ax::Axis3, x1, x2, y1, y2, z1, z2)

Set the axis x-limits to x1 and x2, the y-limits to y1 and y2, and the z-limits to z1 and z2. If limits are ordered high-low, this reverses the axis orientation.

limits!(ax::Axis3, rect::Rect3)

Set the axis limits to rect. If limits are ordered high-low, this reverses the axis orientation.

lines

lines(positions)
lines(x, y)
lines(x, y, z)

Creates a connected line plot for each element in (x, y, z), (x, y) or positions.

NaN values are displayed as gaps in the line.

Attributes

Specific to `Lines`

color=theme(scene, :linecolor) sets the color of the line. If no color is set, multiple calls to line! will cycle through the axis color palette. Otherwise, one can set one color per line point by passing a Vector{<:Colorant}, or one colorant for the whole line. If color is a vector of numbers, the colormap args are used to map the numbers to colors.
cycle::Vector{Symbol} = [:color] sets which attributes to cycle when creating multiple plots.
linestyle::Union{Nothing, Symbol, Linestyle} = nothing sets the pattern of the line e.g. :solid, :dot, :dashdot. For custom patterns look at Linestyle(Number[...]).
linewidth::Union{Real, Vector} = 1.5 sets the width of the line in pixel units.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

lines!

No documentation found.

MakieCore.lines! is a Function.

# 1 method for generic function "lines!" from MakieCore:
 [1] lines!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

linesegments

linesegments(positions)
linesegments(vector_of_2tuples_of_points)
linesegments(x, y)
linesegments(x, y, z)

Plots a line for each pair of points in (x, y, z), (x, y), or positions.

Attributes

Specific to `LineSegments`

color=theme(scene, :linecolor) sets the color of the linesegments. If no color is set, multiple calls to linesegments! will cycle through the axis color palette. Otherwise, one can set one color per line point or one color per linesegment by passing a Vector{<:Colorant}, or one colorant for the whole line. If color is a vector of numbers, the colormap args are used to map the numbers to colors.
cycle::Vector{Symbol} = [:color] sets which attributes to cycle when creating multiple plots.
linestyle::Union{Nothing, Symbol, Vector} = nothing sets the pattern of the line (e.g. :solid, :dot, :dashdot)
linewidth::Union{Real, Vector} = 1.5 sets the width of the line in pixel units.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

linesegments!

No documentation found.

MakieCore.linesegments! is a Function.

# 1 method for generic function "linesegments!" from MakieCore:
 [1] linesegments!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

linkaxes!

linkaxes!(a::Axis, others...)

Link both x and y axes of all given Axis so that they stay synchronized.

linkxaxes!

linkxaxes!(a::Axis, others...)

Link the x axes of all given Axis so that they stay synchronized.

linkyaxes!

linkyaxes!(a::Axis, others...)

Link the y axes of all given Axis so that they stay synchronized.

mesh

mesh(x, y, z)
mesh(mesh_object)
mesh(x, y, z, faces)
mesh(xyz, faces)

Plots a 3D or 2D mesh. Supported mesh_objects include Mesh types from GeometryBasics.jl.

Attributes

Specific to `Mesh`

color=theme(scene, :patchcolor) sets the color of the mesh. Can be a Vector{<:Colorant} for per vertex colors or a single Colorant. A Matrix{<:Colorant} can be used to color the mesh with a texture, which requires the mesh to contain texture coordinates. Vector or Matrices of numbers can be used as well, which will use the colormap arguments to map the numbers to colors.
interpolate::Bool = false sets whether colors should be interpolated.

3D shading attributes

shading = Makie.automatic sets the lighting algorithm used. Options are NoShading (no lighting), FastShading (AmbientLight + PointLight) or MultiLightShading (Multiple lights, GLMakie only). Note that this does not affect RPRMakie.
diffuse::Vec3f = Vec3f(1.0) sets how strongly the red, green and blue channel react to diffuse (scattered) light.
specular::Vec3f = Vec3f(0.4) sets how strongly the object reflects light in the red, green and blue channels.
shininess::Real = 32.0 sets how sharp the reflection is.
backlight::Float32 = 0f0 sets a weight for secondary light calculation with inverted normals.
ssao::Bool = 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.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

mesh!

No documentation found.

MakieCore.mesh! is a Function.

# 1 method for generic function "mesh!" from MakieCore:
 [1] mesh!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

meshscatter

meshscatter(positions)
meshscatter(x, y)
meshscatter(x, y, z)

Plots a mesh for each element in (x, y, z), (x, y), or positions (similar to scatter). markersize is a scaling applied to the primitive passed as marker.

Attributes

Specific to `MeshScatter`

color = theme(scene, :markercolor) sets the color of the marker. If no color is set, multiple calls to meshscatter! will cycle through the axis color palette. Otherwise, one can set one color per point by passing a Vector{<:Colorant}, or one colorant for the whole meshscatterplot. If color is a vector of numbers, the colormap args are used to map the numbers to colors.
cycle::Vector{Symbol} = [:color] sets which attributes to cycle when creating multiple plots.
marker::Union{Symbol, GeometryBasics.GeometryPrimitive, GeometryBasics.Mesh} sets the scattered mesh.
markersize::Union{<:Real, Vec3f} = 0.1 sets the scale of the mesh. This can be given as a Vector to apply to each scattered mesh individually.
rotations::Union{Real, Vec3f, Quaternion} = 0 sets the rotation of the mesh. A numeric rotation is around the z-axis, a Vec3f causes the mesh to rotate such that the the z-axis is now that vector, and a quaternion describes a general rotation. This can be given as a Vector to apply to each scattered mesh individually.

3D shading attributes

shading = Makie.automatic sets the lighting algorithm used. Options are NoShading (no lighting), FastShading (AmbientLight + PointLight) or MultiLightShading (Multiple lights, GLMakie only). Note that this does not affect RPRMakie.
diffuse::Vec3f = Vec3f(1.0) sets how strongly the red, green and blue channel react to diffuse (scattered) light.
specular::Vec3f = Vec3f(0.4) sets how strongly the object reflects light in the red, green and blue channels.
shininess::Real = 32.0 sets how sharp the reflection is.
backlight::Float32 = 0f0 sets a weight for secondary light calculation with inverted normals.
ssao::Bool = 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.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

meshscatter!

No documentation found.

MakieCore.meshscatter! is a Function.

# 1 method for generic function "meshscatter!" from MakieCore:
 [1] meshscatter!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

mouse_buttons

Registers a callback for the mouse buttons + modifiers returns Observable{NTuple{4, Int}}GLFW Docs

mouse_position

Registers a callback for the mouse cursor position. returns an Observable{Vec{2, Float64}}, which is not in scene coordinates, with the upper left window corner being 0 GLFW Docs

mouseover

mouseover(fig/ax/scene, plots::AbstractPlot...)

Returns true if the mouse currently hovers any of plots.

mouseposition

mouseposition(scene = hovered_scene())

Return the current position of the mouse in data coordinates of the given scene.

By default uses the scene that the mouse is currently hovering over.

mouseposition_px

No documentation found.

Makie.mouseposition_px is a Function.

# 3 methods for generic function "mouseposition_px" from Makie:
 [1] mouseposition_px(scene::Scene)
     @ ~/work/Makie.jl/Makie.jl/src/interaction/interactive_api.jl:194
 [2] mouseposition_px()
     @ ~/work/Makie.jl/Makie.jl/src/interaction/interactive_api.jl:194
 [3] mouseposition_px(x)
     @ ~/work/Makie.jl/Makie.jl/src/interaction/interactive_api.jl:193

ncols

ncols(g::GridLayout)

Return the number of columns in g.

nrows

nrows(g::GridLayout)

Return the number of rows in g.

off

off(observable::AbstractObservable, f)

Removes f from listeners of observable.

Returns true if f could be removed, otherwise false.

off(obsfunc::ObserverFunction)

Remove the listener function obsfunc.f from the listeners of obsfunc.observable. Once obsfunc goes out of scope, this should allow obsfunc.f and all the values it might have closed over to be garbage collected (unless there are other references to it).

old_cam3d!

old_cam3d!(scene; kwargs...)

An alias to old_cam3d_turntable!. Creates a 3D camera for scene, which rotates around the plot's axis.

old_cam3d_cad!

old_cam3d_cad!(scene; kw_args...)

Creates a 3D camera for scene which rotates around the viewer's "up" axis - similarly to how it's done in CAD software cameras.

old_cam3d_turntable!

old_cam3d_turntable!(scene; kw_args...)

Creates a 3D camera for scene, which rotates around the plot's axis.

on(f, observable::AbstractObservable; weak = false, priority=0, update=false)::ObserverFunction

Adds function f as listener to observable. Whenever observable's value is set via observable[] = val, f is called with val.

Returns an ObserverFunction that wraps f and observable and allows to disconnect easily by calling off(observerfunction) instead of off(f, observable). If instead you want to compute a new Observable from an old one, use map(f, ::Observable).

If weak = true is set, the new connection will be removed as soon as the returned ObserverFunction is not referenced anywhere and is garbage collected. This is useful if some parent object makes connections to outside observables and stores the resulting ObserverFunction instances. Then, once that parent object is garbage collected, the weak observable connections are removed automatically.

Example

julia> obs = Observable(0)
Observable(0)

julia> on(obs) do val
           println("current value is ", val)
       end
ObserverFunction defined at REPL[17]:2 operating on Observable(0)
julia> obs[] = 5;
current value is 5

One can also give the callback a priority, to enable always calling a specific callback before/after others, independent of the order of registration. The callback with the highest priority gets called first, the default is zero, and the whole range of Int can be used. So one can do:

julia> obs = Observable(0)
julia> on(obs; priority=-1) do x
           println("Hi from first added")
       end
julia> on(obs) do x
           println("Hi from second added")
       end
julia> obs[] = 2
Hi from second added
Hi from first added

If you set update=true, on will call f(obs[]) immediately:

julia> on(Observable(1); update=true) do x
    println("hi")
end
hi

on(f, c::Camera, observables::Observable...)

When mapping over observables for the camera, we store them in the steering_node vector, to make it easier to disconnect the camera steering signals later!

onany

onany(f, args...; weak::Bool = false, priority::Int = 0, update::Bool = false)

Calls f on updates to any observable refs in args. args may contain any number of Observable objects. f will be passed the values contained in the refs as the respective argument. All other objects in args are passed as-is.

Attributes

Available attributes and their defaults for Plot{Makie.pie} are:

  color           :gray
  inner_radius    0
  inspectable     true
  normalize       true
  offset          0
  radius          1
  strokecolor     :black
  strokewidth     1
  transparency    false
  vertex_per_deg  1
  visible         true

pie!

No documentation found.

Makie.pie! is a Function.

# 1 method for generic function "pie!" from Makie:
 [1] pie!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

pixelarea

No documentation found.

Makie.pixelarea is a Function.

# 1 method for generic function "pixelarea" from Makie:
 [1] pixelarea(args...; kwargs...)
     @ deprecated.jl:113

plot

No documentation found.

MakieCore.plot is a Function.

# 1 method for generic function "plot" from MakieCore:
 [1] plot(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:39

plot!

No documentation found.

MakieCore.plot! is a Function.

# 65 methods for generic function "plot!" from MakieCore:
  [1] plot!(plot::Plot{MakieCore.plot, Tuple{Makie.GridLayoutSpec}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/specapi.jl:730
  [2] plot!(fa::Makie.FigureAxis, plot)
     @ Makie ~/work/Makie.jl/Makie.jl/src/figureplotting.jl:313
  [3] plot!(ax::Axis, P::Type{<:Plot{Makie.rainclouds}}, allattrs::Attributes, category_labels, data_array)
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/raincloud.jl:138
  [4] plot!(sc::Plot{Main.FD_SANDBOX_12283929528957551597.stockchart, <:Tuple{AbstractVector{<:Real}, AbstractVector{<:Main.FD_SANDBOX_12283929528957551597.StockValue}}})
     @ Main.FD_SANDBOX_12283929528957551597 none:1
  [5] plot!(plot::Plot{RPRMakie.matball})
     @ RPRMakie ~/work/Makie.jl/Makie.jl/RPRMakie/src/meshes.jl:172
  [6] plot!(plot::Plot{Makie.band})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/band.jl:33
  [7] plot!(axis::Plot{Makie.axis3d})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/axis.jl:320
  [8] plot!(p::Plot{Makie.ablines})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/ablines.jl:18
  [9] plot!(plot::Plot{Makie.annotations})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/annotations.jl:21
 [10] plot!(p::Plot{Makie.arc})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/arc.jl:24
 [11] plot!(arrowplot::Arrows{<:Tuple{AbstractVector{<:Point{N}}, V}}) where {N, V}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/arrows.jl:115
 [12] plot!(p::Plot{Makie.barplot})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/barplot.jl:240
 [13] plot!(pl::Plot{Makie.bracket})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/bracket.jl:43
 [14] plot!(plot::Plot{Makie.contour, <:Tuple{X, Y, Z, Vol}}) where {X, Y, Z, Vol}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/contours.jl:119
 [15] plot!(plot::T) where T<:Union{Plot{Makie.contour}, Plot{Makie.contour3d}}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/contours.jl:205
 [16] plot!(c::Plot{Makie.contourf, <:Tuple{var"#s317", var"#s29", var"#s28"} where {var"#s317"<:(AbstractVector{<:Real}), var"#s29"<:(AbstractVector{<:Real}), var"#s28"<:(AbstractMatrix{<:Real})}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/contourf.jl:70
 [17] plot!(p::Plot{Makie.datashader, <:Tuple{var"#s317"} where var"#s317"<:(AbstractVector{<:Point})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/datashader.jl:377
 [18] plot!(p::Plot{Makie.datashader, <:Tuple{Dict{String, Vector{Point{2, Float32}}}}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/datashader.jl:432
 [19] plot!(plot::Plot{Makie.errorbars, T}) where T<:Tuple{AbstractVector{<:Union{NTuple{4, T}, StaticArraysCore.StaticArray{Tuple{4}, T, 1}} where T}}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/error_and_rangebars.jl:137
 [20] plot!(plot::Plot{Makie.rangebars, T}) where T<:Tuple{AbstractVector{<:Union{Tuple{T, T, T}, StaticArraysCore.StaticArray{Tuple{3}, T, 1}} where T}}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/error_and_rangebars.jl:167
 [21] plot!(p::Union{Plot{Makie.hlines}, Plot{Makie.vlines}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvlines.jl:48
 [22] plot!(p::Union{Plot{Makie.hspan}, Plot{Makie.vspan}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/hvspan.jl:45
 [23] plot!(plot::Plot{Makie.pie})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/pie.jl:25
 [24] plot!(plot::Poly{<:Tuple{Union{GeometryBasics.GeometryPrimitive, GeometryBasics.Mesh}}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/poly.jl:11
 [25] plot!(plot::Poly{<:Tuple{var"#s317"} where var"#s317"<:Union{GeometryBasics.Polygon, AbstractVector{<:Union{AbstractVector{<:Union{Tuple{Vararg{T, N}}, StaticArraysCore.StaticArray{Tuple{N}, T, 1}} where {N, T}}, Tuple{Vararg{T, N}} where {N, T}, GeometryBasics.AbstractMesh, GeometryBasics.HyperRectangle, GeometryBasics.MultiPolygon, GeometryBasics.Polygon, StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T}, Circle}}}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/poly.jl:118
 [26] plot!(plot::Mesh{<:Tuple{var"#s317"} where var"#s317"<:AbstractVector{P}}) where P<:Union{GeometryBasics.AbstractMesh, GeometryBasics.Polygon}
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/poly.jl:165
 [27] plot!(p::Plot{Makie.scatterlines, <:Tuple{Vararg{Any, N}}}) where N
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/scatterlines.jl:34
 [28] plot!(p::Plot{Makie.spy})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/spy.jl:40
 [29] plot!(p::Plot{Makie.stairs, <:Tuple{var"#s317"} where var"#s317"<:(AbstractVector{<:Point2})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/stairs.jl:25
 [30] plot!(s::Plot{Makie.stem, <:Tuple{var"#s317"} where var"#s317"<:(AbstractVector{<:Point})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/stem.jl:52
 [31] plot!(p::Plot{Makie.streamplot})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/streamplot.jl:169
 [32] plot!(plot::Plot{Makie.timeseries})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/timeseries.jl:37
 [33] plot!(c::Plot{Makie.tricontourf, <:Tuple{var"#s317", var"#s29"} where {var"#s317"<:DelaunayTriangulation.Triangulation, var"#s29"<:(AbstractVector{<:Real})}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/tricontourf.jl:118
 [34] plot!(p::Plot{Makie.triplot, <:Tuple{var"#s317"} where var"#s317"<:(Vector{<:Point})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/triplot.jl:183
 [35] plot!(p::Plot{Makie.triplot, <:Tuple{var"#s317"} where var"#s317"<:DelaunayTriangulation.Triangulation})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/triplot.jl:197
 [36] plot!(plot::Plot{Makie.volumeslices})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/volumeslices.jl:20
 [37] plot!(p::Plot{Makie.voronoiplot, <:Tuple{var"#s317"} where var"#s317"<:(Vector{<:Point{N}})}) where N
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/voronoiplot.jl:133
 [38] plot!(p::Plot{Makie.voronoiplot, <:Tuple{var"#s317"} where var"#s317"<:DelaunayTriangulation.VoronoiTessellation})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/voronoiplot.jl:183
 [39] plot!(p::Plot{Makie.waterfall})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/waterfall.jl:35
 [40] plot!(plot::Wireframe{<:Tuple{var"#s317", var"#s29", var"#s28"} where {var"#s317", var"#s29", var"#s28"<:(AbstractMatrix)}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/wireframe.jl:29
 [41] plot!(plot::Plot{MakieCore.wireframe, Tuple{T}}) where T
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/wireframe.jl:41
 [42] plot!(p::Plot{Makie.tooltip, <:Tuple{var"#s317"} where var"#s317"<:(Union{Tuple{Vararg{T, N}}, StaticArraysCore.StaticArray{Tuple{N}, T, 1}} where {N, T})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/tooltip.jl:83
 [43] plot!(plot::Plot{Makie.tooltip, <:Tuple{var"#s317", var"#s29"} where {var"#s317"<:(Union{Tuple{Vararg{T, N}}, StaticArraysCore.StaticArray{Tuple{N}, T, 1}} where {N, T}), var"#s29"<:AbstractString}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/tooltip.jl:76
 [44] plot!(p::Plot{Makie.plotlist, <:Tuple{var"#s1274"} where var"#s1274"<:(AbstractArray{PlotSpec})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/specapi.jl:486
 [45] plot!(plot::Plot{Makie.stephist})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/hist.jl:56
 [46] plot!(plot::Plot{Makie.hist})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/hist.jl:166
 [47] plot!(plot::Plot{Makie.density, <:Tuple{var"#s1274"} where var"#s1274"<:(AbstractVector)})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/density.jl:57
 [48] plot!(p::Plot{Makie.qqplot})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/distributions.jl:125
 [49] plot!(plot::Plot{Makie.crossbar})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/crossbar.jl:54
 [50] plot!(plot::Plot{Makie.boxplot})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/boxplot.jl:82
 [51] plot!(plot::Plot{Makie.violin})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/violin.jl:52
 [52] plot!(hb::Plot{Makie.hexbin, <:Tuple{var"#s1274"} where var"#s1274"<:(AbstractVector{<:Point2})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/stats/hexbin.jl:81
 [53] plot!(plot::Plot{Makie.series})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/series.jl:67
 [54] plot!(plot::MakieCore.Text{<:Tuple{var"#s1946"} where var"#s1946"<:(AbstractArray{<:AbstractString})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:144
 [55] plot!(plot::MakieCore.Text{<:Tuple{var"#s1946"} where var"#s1946"<:(AbstractArray{<:Tuple{var"#s1944", var"#s1925"} where {var"#s1944", var"#s1925"<:Point}})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:150
 [56] plot!(plot::MakieCore.Text{<:Tuple{var"#s1946"} where var"#s1946"<:(AbstractArray{<:Makie.GlyphCollection})})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:142
 [57] plot!(plot::MakieCore.Text{<:Tuple{var"#s1946"} where var"#s1946"<:Makie.GlyphCollection})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:141
 [58] plot!(plot::MakieCore.Text{<:Tuple{var"#s1946"} where var"#s1946"<:AbstractString})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:126
 [59] plot!(plot::Plot{Makie.rainclouds})
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/raincloud.jl:194
 [60] plot!(plot::MakieCore.Text)
     @ Makie ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:7
 [61] plot!(::Plot{F}) where F
     @ Makie ~/work/Makie.jl/Makie.jl/src/interfaces.jl:230
 [62] plot!(ax::Makie.AbstractAxis, plot::AbstractPlot)
     @ Makie ~/work/Makie.jl/Makie.jl/src/figureplotting.jl:315
 [63] plot!(scene::Union{AbstractScene, MakieCore.ScenePlot}, plot::Plot)
     @ Makie ~/work/Makie.jl/Makie.jl/src/interfaces.jl:264
 [64] plot!(fig::Union{GridPosition, Figure}, plot::Plot{MakieCore.plot, Tuple{Makie.GridLayoutSpec}})
     @ Makie ~/work/Makie.jl/Makie.jl/src/specapi.jl:732
 [65] plot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:40

plotkey

No documentation found.

MakieCore.plotkey is a Function.

# 4 methods for generic function "plotkey" from MakieCore:
 [1] plotkey(::Nothing)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:23
 [2] plotkey(::T) where T<:AbstractPlot
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:22
 [3] plotkey(::Type{<:AbstractPlot{Typ}}) where Typ
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:21
 [4] plotkey(any)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:24

plotlist

plotlist!(
    [
        PlotSpec(:Scatter, args...; kwargs...),
        PlotSpec(:Lines, args...; kwargs...),
    ]
)

Plots a list of PlotSpec's, which can be an observable, making it possible to create efficiently animated plots with the following API:

Example

using GLMakie
import Makie.SpecApi as S

fig = Figure()
ax = Axis(fig[1, 1])
plots = Observable([S.heatmap(0 .. 1, 0 .. 1, Makie.peaks()), S.lines(0 .. 1, sin.(0:0.01:1); color=:blue)])
pl = plot!(ax, plots)
display(fig)

# Updating the plot dynamically
plots[] = [S.heatmap(0 .. 1, 0 .. 1, Makie.peaks()), S.lines(0 .. 1, sin.(0:0.01:1); color=:red)]
plots[] = [
    S.image(0 .. 1, 0 .. 1, Makie.peaks()),
    S.poly(Rect2f(0.45, 0.45, 0.1, 0.1)),
    S.lines(0 .. 1, sin.(0:0.01:1); linewidth=10, color=Makie.resample_cmap(:viridis, 101)),
]

plots[] = [
    S.surface(0..1, 0..1, Makie.peaks(); colormap = :viridis, translation = Vec3f(0, 0, -1)),
]

plotlist!

No documentation found.

Makie.plotlist! is a Function.

# 1 method for generic function "plotlist!" from Makie:
 [1] plotlist!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

plots

No documentation found.

Makie.plots is a Function.

# 2 methods for generic function "plots" from Makie:
 [1] plots(scene::Union{AbstractScene, MakieCore.ScenePlot})
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:519
 [2] plots(x)
     @ ~/work/Makie.jl/Makie.jl/src/scenes.jl:518

poly

poly(vertices, indices; kwargs...)
poly(points; kwargs...)
poly(shape; kwargs...)
poly(mesh; kwargs...)

Plots a polygon based on the arguments given. When vertices and indices are given, it functions similarly to mesh. When points are given, it draws one polygon that connects all the points in order. When a shape is given (essentially anything decomposable by GeometryBasics), it will plot decompose(shape).

poly(coordinates, connectivity; kwargs...)

Plots polygons, which are defined by coordinates (the coordinates of the vertices) and connectivity (the edges between the vertices).

Attributes

Specific to `Poly`

color=theme(scene, :patchcolor) sets the color of the poly. Can be a Vector{<:Colorant} for per vertex colors or a single Colorant. A Matrix{<:Colorant} can be used to color the mesh with a texture, which requires the mesh to contain texture coordinates. Vector or Matrices of numbers can be used as well, which will use the colormap arguments to map the numbers to colors. One can also use Makie.LinePattern, to cover the poly with a regular stroke pattern.
strokecolor::Union{Symbol, <:Colorant} = :black sets the color of the outline around a marker.
strokecolormap::Union{Symbol, Vector{<:Colorant}} = :viridissets the colormap that is sampled for numericcolor`s.
strokewidth::Real = 0 sets the width of the outline around a marker.
linestyle::Union{Nothing, Symbol, Vector} = nothing sets the pattern of the line (e.g. :solid, :dot, :dashdot)

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

poly!

No documentation found.

MakieCore.poly! is a Function.

# 1 method for generic function "poly!" from MakieCore:
 [1] poly!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

qqnorm

qqnorm(y; kwargs...)

Shorthand for qqplot(Normal(0,1), y), i.e., draw a Q-Q plot of y against the standard normal distribution. See qqplot for more details.

qqnorm!

No documentation found.

Makie.qqnorm! is a Function.

# 1 method for generic function "qqnorm!" from Makie:
 [1] qqnorm!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

qqplot

qqplot(x, y; kwargs...)

Draw a Q-Q plot, comparing quantiles of two distributions. y must be a list of samples, i.e., AbstractVector{<:Real}, whereas x can be

a list of samples,
an abstract distribution, e.g. Normal(0, 1),
a distribution type, e.g. Normal.

In the last case, the distribution type is fitted to the data y.

The attribute qqline (defaults to :none) determines how to compute a fit line for the Q-Q plot. Possible values are the following.

:identity draws the identity line.
:fit computes a least squares line fit of the quantile pairs.
:fitrobust computes the line that passes through the first and third quartiles of the distributions.
:none omits drawing the line.

Broadly speaking, qqline = :identity is useful to see if x and y follow the same distribution, whereas qqline = :fit and qqline = :fitrobust are useful to see if the distribution of y can be obtained from the distribution of x via an affine transformation.

Graphical attributes are

color to control color of both line and markers (if markercolor is not specified)
linestyle
linewidth
markercolor
strokecolor
strokewidth
marker
markersize

qqplot!

No documentation found.

Makie.qqplot! is a Function.

# 1 method for generic function "qqplot!" from Makie:
 [1] qqplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

qrotation

No documentation found.

Makie.qrotation is a Function.

# 1 method for generic function "qrotation" from Makie:
 [1] qrotation(axis::StaticArraysCore.StaticArray{Tuple{3}, T, 1} where T, theta::Number)
     @ ~/work/Makie.jl/Makie.jl/src/utilities/quaternions.jl:39

quiver

arrows(points, directions; kwargs...)
arrows(x, y, u, v)
arrows(x::AbstractVector, y::AbstractVector, u::AbstractMatrix, v::AbstractMatrix)
arrows(x, y, z, u, v, w)
arrows(x, y, [z], f::Function)

If x, y, u, v are <: AbstractVector, then each 'row' is plotted as a single vector.

If u, v are <: AbstractMatrix, then x and y are interpreted as specifications for a grid, and u, v are plotted as arrows along the grid.

arrows can also work in three dimensions.

If a Function is provided in place of u, v, [w], then it must accept a Point as input, and return an appropriately dimensioned Point, Vec, or other array-like output.

Attributes

Available attributes and their defaults for Arrows are:

  align           :origin
  alpha           1.0
  arrowcolor      MakieCore.Automatic()
  arrowhead       MakieCore.Automatic()
  arrowsize       MakieCore.Automatic()
  arrowtail       MakieCore.Automatic()
  backlight       0.0f0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  depth_shift     0.0f0
  diffuse         1.0
  highclip        MakieCore.Automatic()
  inspectable     true
  lengthscale     1.0f0
  linecolor       MakieCore.Automatic()
  linestyle       "nothing"
  linewidth       MakieCore.Automatic()
  lowclip         MakieCore.Automatic()
  markerspace     :pixel
  nan_color       :transparent
  normalize       false
  overdraw        false
  quality         32
  shading         MakieCore.Automatic()
  shininess       32.0f0
  space           :data
  specular        0.2
  ssao            false
  transparency    false
  visible         true

quiver!

See arrows.

rainclouds

rainclouds!(ax, category_labels, data_array; plot_boxplots=true, plot_clouds=true, kwargs...)

Plot a violin (/histogram), boxplot and individual data points with appropriate spacing between each.

Arguments

ax: Axis used to place all these plots onto.
category_labels: Typically Vector{String} with a label for each element in data_array
data_array: Typically Vector{Float64} used for to represent the datapoints to plot.

Keywords

gap=0.2: Distance between elements of x-axis.
side=:left: Can take values of :left, :right, determines where the violin plot will be, relative to the scatter points
dodge: vector of Integer` (length of data) of grouping variable to create multiple side-by-side boxes at the same x position
dodge_gap = 0.03: spacing between dodged boxes
n_dodge: the number of categories to dodge (defaults to maximum(dodge))
color: a single color, or a vector of colors, one for each point

Violin/Histogram Plot Specific Keywords

clouds=violin: [violin, hist, nothing] to show cloud plots either as violin or histogram plot, or no cloud plot.
hist_bins=30: if clouds=hist, this passes down the number of bins to the histogram call.
cloud_width=1.0: Determines size of violin plot. Corresponds to width keyword arg in

violin.

orientation=:vertical orientation of raindclouds (:vertical or :horizontal)
violin_limits=(-Inf, Inf): specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema)

Box Plot Specific Keywords

plot_boxplots=true: Boolean to show boxplots to summarize distribution of data.
boxplot_width=0.1: Width of the boxplot in category x-axis absolute terms.
center_boxplot=true: Determines whether or not to have the boxplot be centered in the category.
whiskerwidth=0.5: The width of the Q1, Q3 whisker in the boxplot. Value as a portion of the boxplot_width.
strokewidth=1.0: Determines the stroke width for the outline of the boxplot.
show_median=true: Determines whether or not to have a line should the median value in the boxplot.
boxplot_nudge=0.075: Determines the distance away the boxplot should be placed from the center line when center_boxplot is false. This is the value used to recentering the boxplot.
show_boxplot_outliers: show outliers in the boxplot as points (usually confusing when

paired with the scatter plot so the default is to not show them)

Scatter Plot Specific Keywords

side_nudge: Default value is 0.02 if plot_boxplots is true, otherwise 0.075 default.
jitter_width=0.05: Determines the width of the scatter-plot bar in category x-axis absolute terms.
markersize=2: Size of marker used for the scatter plot.

Axis General Keywords

title
xlabel
ylabel

rainclouds!

No documentation found.

Makie.rainclouds! is a Function.

# 1 method for generic function "rainclouds!" from Makie:
 [1] rainclouds!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

rangebars

rangebars(val, low, high; kwargs...)
rangebars(val, low_high; kwargs...)
rangebars(val_low_high; kwargs...)

Plots rangebars at val in one dimension, extending from low to high in the other dimension given the chosen direction. The low_high argument can be a vector of tuples or intervals.

If you want to plot errors relative to a reference value, use errorbars.

Attributes

Available attributes and their defaults for Plot{Makie.rangebars} are:

  color         :black
  colormap      :viridis
  colorrange    MakieCore.Automatic()
  colorscale    identity
  cycle         [:color]
  direction     :y
  inspectable   true
  linewidth     1.5
  transparency  false
  visible       true
  whiskerwidth  0

rangebars!

No documentation found.

Makie.rangebars! is a Function.

# 1 method for generic function "rangebars!" from Makie:
 [1] rangebars!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

record

record(func, figurelike, path; backend=current_backend(), kwargs...)
record(func, figurelike, path, iter; backend=current_backend(), kwargs...)

The first signature provides func with a VideoStream, which it should call recordframe!(io) on when recording a frame.

The second signature iterates iter, calling recordframe!(io) internally after calling func with the current iteration element.

Both notations require a Figure, FigureAxisPlot or Scene figure to work. The animation is then saved to path, with the format determined by path's extension.

Under the hood, record is just video_io = Record(func, figurelike, [iter]; same_kw...); save(path, video_io). Record can be used directly as well to do the saving at a later point, or to inline a video directly into a Notebook (the video supports, show(video_io, "text/html") for that purpose).

Options one can pass via `kwargs...`:

backend::Module = current_backend(): set the backend to write out video, can be set to CairoMakie, GLMakie, WGLMakie, RPRMakie.

Backend options

See ?Backend.Screen or Base.doc(Backend.Screen) for applicable options that can be passed and forwarded to the backend.

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"`.

Typical usage

record(figure, "video.mp4", itr) do i
    func(i) # or some other manipulation of the figure
end

or, for more tweakability,

record(figure, "test.gif") do io
    for i = 1:100
        func!(figure)     # animate figure
        recordframe!(io)  # record a new frame
    end
end

If you want a more tweakable interface, consider using VideoStream and save.

Extended help

Examples

fig, ax, p = lines(rand(10))
record(fig, "test.gif") do io
    for i in 1:255
        p[:color] = RGBf(i/255, (255 - i)/255, 0) # animate figure
        recordframe!(io)
    end
end

fig, ax, p = lines(rand(10))
record(fig, "test.gif", 1:255) do i
    p[:color] = RGBf(i/255, (255 - i)/255, 0) # animate figure
end

record_events

record_events(f, scene::Scene, path::String)

Records all window events that happen while executing function f for scene and serializes them to path.

recordframe!

recordframe!(io::VideoStream)

Adds a video frame to the VideoStream io.

register_interaction!

register_interaction!(parent, name::Symbol, interaction)

Register interaction with parent under the name name. The parent will call process_interaction(interaction, event, parent) whenever suitable events happen.

The interaction can be removed with deregister_interaction! or temporarily toggled with activate_interaction! / deactivate_interaction!.

register_interaction!(interaction::Function, parent, name::Symbol)

Register interaction with parent under the name name. The parent will call process_interaction(interaction, event, parent) whenever suitable events happen. This form with the first Function argument is especially intended for do syntax.

The interaction can be removed with deregister_interaction! or temporarily toggled with activate_interaction! / deactivate_interaction!.

replace_automatic!

Like get!(f, dict, key) but also calls f and replaces key when the corresponding value is nothing

replay_events

replayevents(f, scene::Scene, path::String) replayevents(scene::Scene, path::String)

Replays the serialized events recorded with record_events in path in scene.

resample_cmap

resample_cmap(cmap, ncolors::Integer; alpha=1.0)

cmap: anything that to_colormap accepts
ncolors: number of desired colors
alpha: additional alpha applied to each color. Can also be an array, matching colors, or a tuple giving a start + stop alpha value.

reset_limits!

reset_limits!(ax; xauto = true, yauto = true)

Resets the axis limits depending on the value of ax.limits. If one of the two components of limits is nothing, that value is either copied from the targetlimits if xauto or yauto is false, respectively, or it is determined automatically from the plots in the axis. If one of the components is a tuple of two numbers, those are used directly.

resize_to_layout!

resize_to_layout!(fig::Figure)

Resize fig so that it fits the current contents of its top GridLayout. If a GridLayout contains fixed-size content or aspect-constrained columns, for example, it is likely that the solved size of the GridLayout differs from the size of the Figure. This can result in superfluous whitespace at the borders, or content clipping at the figure edges. Once resized, all content should fit the available space, including the Figure's outer padding.

rich

No documentation found.

Makie.rich is a Function.

# 1 method for generic function "rich" from Makie:
 [1] rich(args...; kwargs...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:291

right

No documentation found.

Makie.right is a Function.

# 1 method for generic function "right" from Makie:
 [1] right(rect::Rect2)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/geometrybasics_extension.jl:3

rlims!

rlims!(ax::PolarAxis[, rmin], rmax)

Sets the radial limits of a given PolarAxis.

rotate!

rotate!(Accum, t::Transformable, axis_rot...)

Apply a relative rotation to the transformable, by multiplying by the current rotation.

rotate!(t::Transformable, axis_rot::Quaternion)
rotate!(t::Transformable, axis_rot::AbstractFloat)
rotate!(t::Transformable, axis_rot...)

Apply an absolute rotation to the transformable. Rotations are all internally converted to Quaternions.

rotate_cam!

rotate_cam!(scene, cam::Camera3D, angles::Vec3)

Rotates the camera by the given angles around the camera x- (left, right), y- (up, down) and z-axis (in out). The rotation around the y axis is applied first, then x, then y.

Note that this method reacts to fix_x_key etc and fixed_axis. The former restrict the rotation around a specific axis when a given key is pressed. The latter keeps the camera y axis fixed as the data space z axis.

rotate_cam!(scene::Scene, theta_v::Number...)
rotate_cam!(scene::Scene, theta_v::VecTypes)

Rotate the camera of the Scene by the given rotation. Passing theta_v = (α, β, γ) will rotate the camera according to the Euler angles (α, β, γ).

rowgap!

rowgap!(gl::GridLayout, i::Integer, s::Union{Fixed, Relative, Real})
rowgap!(gl::GridLayout, s::Union{Fixed, Relative, Real})

Set the gap between rows in gl. The two-argument version sets all row gaps in gl. The three-argument version sets the gap between rows i and i+1. Passing a real number to s has the same behaviour as passing Fixed(s).

Supported Formats

GLMakie: .png
CairoMakie: .svg, .pdf and .png
WGLMakie: .png

Supported Keyword Arguments

All Backends

size: (width::Int, height::Int) of the scene in dimensionless units.
update: Whether the figure should be updated before saving. This resets the limits of all Axes in the figure. Defaults to true.
backend: Specify the Makie backend that should be used for saving. Defaults to the current backend.
px_per_unit: The size of one scene unit in px when exporting to a bitmap format. This provides a mechanism to export the same scene with higher or lower resolution.
Further keywords will be forwarded to the screen.

CairoMakie

pt_per_unit: The size of one scene unit in pt when exporting to a vector format.

save(path::String, io::VideoStream)

Flushes the video stream and saves it to path. Ideally, path's file extension is the same as the format that the VideoStream was created with (e.g., if created with format "mp4" then path's file extension must be ".mp4"). Otherwise, the video will get converted to the target format. If using record then this is handled for you, as the VideoStream's format is deduced from the file extension of the path passed to record.

scale!

scale!(t::Transformable, x, y)
scale!(t::Transformable, x, y, z)
scale!(t::Transformable, xyz)
scale!(t::Transformable, xyz...)

Scale the given Transformable (a Scene or Plot) to the given arguments. Can take x, y or x, y, z. This is an absolute scaling, and there is no option to perform relative scaling.

scatter

scatter(positions)
scatter(x, y)
scatter(x, y, z)

Plots a marker for each element in (x, y, z), (x, y), or positions.

Attributes

Specific to `Scatter`

color=theme(scene, :markercolor) sets the color of the marker. If no color is set, multiple calls to scatter! will cycle through the axis color palette. Otherwise, one can set one color per point by passing a Vector{<:Colorant}, or one colorant for the whole scatterplot. If color is a vector of numbers, the colormap args are used to map the numbers to colors.
cycle::Vector{Symbol} = [:color] sets which attributes to cycle when creating multiple plots.
marker::Union{Symbol, Char, Matrix{<:Colorant}, BezierPath, Polygon} sets the scatter marker.
markersize::Union{<:Real, Vec2f} = 9 sets the size of the marker.
markerspace::Symbol = :pixel sets the space in which markersize is given. See Makie.spaces() for possible inputs.
strokewidth::Real = 0 sets the width of the outline around a marker.
strokecolor::Union{Symbol, <:Colorant} = :black sets the color of the outline around a marker.
glowwidth::Real = 0 sets the size of a glow effect around the marker.
glowcolor::Union{Symbol, <:Colorant} = (:black, 0) sets the color of the glow effect.
rotations::Union{Real, Billboard, Quaternion} = Billboard(0f0) sets the rotation of the marker. A Billboard rotation is always around the depth axis.
transform_marker::Bool = false controls whether the model matrix (without translation) applies to the marker itself, rather than just the positions. (If this is true, scale! and rotate! will affect the marker.)

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

scatter!

No documentation found.

MakieCore.scatter! is a Function.

# 1 method for generic function "scatter!" from MakieCore:
 [1] scatter!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

scatterlines

scatterlines(xs, ys, [zs]; kwargs...)

Plots scatter markers and lines between them.

Attributes

Available attributes and their defaults for Plot{Makie.scatterlines} are:

  color             :black
  colormap          :viridis
  colorrange        MakieCore.Automatic()
  colorscale        identity
  cycle             [:color]
  inspectable       true
  linestyle         "nothing"
  linewidth         1.5
  marker            :circle
  markercolor       MakieCore.Automatic()
  markercolormap    MakieCore.Automatic()
  markercolorrange  MakieCore.Automatic()
  markersize        9
  strokecolor       :black
  strokewidth       0

scatterlines!

No documentation found.

Makie.scatterlines! is a Function.

# 1 method for generic function "scatterlines!" from Makie:
 [1] scatterlines!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

scroll

Registers a callback for the mouse scroll. returns an Observable{Vec{2, Float64}}, which is an x and y offset. GLFW Docs

select_line

select_line(scene; kwargs...) -> line

Interactively select a line (typically an arrow) on a 2D scene by clicking the left mouse button, dragging and then un-clicking. Return an observable whose value corresponds to the selected line on the scene. In addition the function plots the line on the scene as the user clicks and moves the mouse around. When the button is not clicked any more, the plotted line disappears.

The value of the returned line is updated only when the user un-clicks and only if the selected line has non-zero length.

The kwargs... are propagated into lines! which plots the selected line.

select_point

select_point(scene; kwargs...) -> point

Interactively select a point on a 2D scene by clicking the left mouse button, dragging and then un-clicking. Return an observable whose value corresponds to the selected point on the scene. In addition the function plots the point on the scene as the user clicks and moves the mouse around. When the button is not clicked any more, the plotted point disappears.

The value of the returned point is updated only when the user un-clicks.

The kwargs... are propagated into scatter! which plots the selected point.

select_rectangle

select_rectangle(scene; kwargs...) -> rect

Interactively select a rectangle on a 2D scene by clicking the left mouse button, dragging and then un-clicking. The function returns an observablerect whose value corresponds to the selected rectangle on the scene. In addition the function plots the selected rectangle on the scene as the user clicks and moves the mouse around. When the button is not clicked any more, the plotted rectangle disappears.

The value of the returned observable is updated only when the user un-clicks (i.e. when the final value of the rectangle has been decided) and only if the rectangle has area > 0.

The kwargs... are propagated into lines! which plots the selected rectangle.

series

series(curves;
    linewidth=2,
    color=:lighttest,
    solid_color=nothing,
    labels=nothing,
    # scatter arguments, if any is set != nothing, a scatterplot is added
    marker=nothing,
    markersize=nothing,
    markercolor=automatic,
    strokecolor=nothing,
    strokewidth=nothing)

Curves can be:

AbstractVector{<: AbstractVector{<: Point2}}: the native representation of a series as a vector of lines
AbstractMatrix: each row represents y coordinates of the line, while x goes from 1:size(curves, 1)
AbstractVector, AbstractMatrix: the same as the above, but the first argument sets the x values for all lines
AbstractVector{<: Tuple{X<: AbstractVector, Y<: AbstractVector}}: A vector of tuples, where each tuple contains a vector for the x and y coordinates

series!

No documentation found.

Makie.series! is a Function.

# 1 method for generic function "series!" from Makie:
 [1] series!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

set_close_to!

set_close_to!(slider, value) -> closest_value

Set the slider to the value in the slider's range that is closest to value and return this value. This function should be used to set a slider to a value programmatically, rather than mutating its value observable directly, which doesn't update the slider visually.

Set the slider to the values in the slider's range that are closest to v1 and v2, and return those values ordered min, misl.

set_theme!

set_theme(theme; kwargs...)

Set the global default theme to theme and add / override any attributes given as keyword arguments.

showgradients

showgradients(
    cgrads::AbstractVector{Symbol};
    h = 0.0, offset = 0.2, fontsize = 0.7,
    size = (800, length(cgrads) * 84)
)::Scene

Plots the given colour gradients arranged as horizontal colourbars. If you change the offsets or the font size, you may need to change the resolution.

spy

spy(x::Range, y::Range, z::AbstractSparseArray)

Visualizes big sparse matrices. Usage:

N = 200_000
x = sprand(Float64, N, N, (3(10^6)) / (N*N));
spy(x)
# or if you want to specify the range of x and y:
spy(0..1, 0..1, x)

Attributes

Available attributes and their defaults for Plot{Makie.spy} are:

  colormap     :viridis
  colorrange   MakieCore.Automatic()
  colorscale   identity
  framecolor   :black
  framesize    1
  inspectable  true
  marker       MakieCore.Automatic()
  markersize   MakieCore.Automatic()
  visible      true

spy!

No documentation found.

Makie.spy! is a Function.

# 1 method for generic function "spy!" from Makie:
 [1] spy!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

stairs

stairs(xs, ys; kwargs...)

Plot a stair function.

The step parameter can take the following values:

:pre: horizontal part of step extends to the left of each value in xs.
:post: horizontal part of step extends to the right of each value in xs.
:center: horizontal part of step extends halfway between the two adjacent values of xs.

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Plot{Makie.stairs} are:

  alpha           1.0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  cycle           [:color]
  depth_shift     0.0f0
  highclip        MakieCore.Automatic()
  inspectable     true
  linestyle       "nothing"
  linewidth       1.5
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  step            :pre
  transparency    false
  visible         true

stairs!

No documentation found.

Makie.stairs! is a Function.

# 1 method for generic function "stairs!" from Makie:
 [1] stairs!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

stem

stem(xs, ys, [zs]; kwargs...)

Plots markers at the given positions extending from offset along stem lines.

offset can be a number, in which case it sets y for 2D, and z for 3D stems. It can be a Point2 for 2D plots, as well as a Point3 for 3D plots. It can also be an iterable of any of these at the same length as xs, ys, zs.

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Plot{Makie.stem} are:

  color            :black
  colormap         :viridis
  colorrange       MakieCore.Automatic()
  colorscale       identity
  cycle            [[:stemcolor, :color, :trunkcolor] => :color]
  inspectable      true
  marker           :circle
  markersize       9
  offset           0
  stemcolor        :black
  stemcolormap     :viridis
  stemcolorrange   MakieCore.Automatic()
  stemlinestyle    "nothing"
  stemwidth        1.5
  strokecolor      :black
  strokewidth      0
  trunkcolor       :black
  trunkcolormap    :viridis
  trunkcolorrange  MakieCore.Automatic()
  trunklinestyle   "nothing"
  trunkwidth       1.5
  visible          true

stem!

No documentation found.

Makie.stem! is a Function.

# 1 method for generic function "stem!" from Makie:
 [1] stem!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

stephist

stephist(values; bins = 15, normalization = :none)

Plot a step histogram of values. bins can be an Int to create that number of equal-width bins over the range of values. Alternatively, it can be a sorted iterable of bin edges. The histogram can be normalized by setting normalization.

Shares most options with hist plotting function.

Statistical weights can be provided via the weights keyword argument.

The following attributes can move the histogram around, which comes in handy when placing multiple histograms into one plot:

scale_to = nothing: allows to scale all values to a certain height

Attributes

Available attributes and their defaults for Plot{Makie.stephist} are:

  bins           15
  color          RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
  cycle          [:color => :patchcolor]
  linestyle      :solid
  normalization  :none
  scale_to       "nothing"
  weights        MakieCore.Automatic()

stephist!

No documentation found.

Makie.stephist! is a Function.

# 1 method for generic function "stephist!" from Makie:
 [1] stephist!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

streamplot

streamplot(f::function, xinterval, yinterval; color = norm, kwargs...)

f must either accept f(::Point) or f(x::Number, y::Number). f must return a Point2.

Example:

v(x::Point2{T}) where T = Point2f(x[2], 4*x[1])
streamplot(v, -2..2, -2..2)

One can choose the color of the lines by passing a function color_func(dx::Point) to the color attribute. By default this is set to norm, but can be set to any function or composition of functions. The dx which is passed to color_func is the output of f at the point being colored.

Attributes

Available attributes and their defaults for Plot{Makie.streamplot} are:

  alpha           1.0
  arrow_head      MakieCore.Automatic()
  arrow_size      MakieCore.Automatic()
  color           LinearAlgebra.norm
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  density         1.0
  depth_shift     0.0f0
  gridsize        (32, 32, 32)
  highclip        MakieCore.Automatic()
  inspectable     true
  linestyle       "nothing"
  linewidth       1.5
  lowclip         MakieCore.Automatic()
  maxsteps        500
  nan_color       :transparent
  overdraw        false
  quality         16
  space           :data
  ssao            false
  stepsize        0.01
  transparency    false
  visible         true

Implementation

See the function Makie.streamplot_impl for implementation details.

streamplot!

No documentation found.

Makie.streamplot! is a Function.

# 1 method for generic function "streamplot!" from Makie:
 [1] streamplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

subscript

No documentation found.

Makie.subscript is a Function.

# 1 method for generic function "subscript" from Makie:
 [1] subscript(args...; kwargs...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:292

superscript

No documentation found.

Makie.superscript is a Function.

# 1 method for generic function "superscript" from Makie:
 [1] superscript(args...; kwargs...)
     @ ~/work/Makie.jl/Makie.jl/src/basic_recipes/text.jl:293

surface

surface(x, y, z)
surface(z)

Plots a surface, where (x, y) define a grid whose heights are the entries in z. x and y may be Vectors which define a regular grid, orMatrices which define an irregular grid.

Attributes

Specific to `Surface`

invert_normals::Bool = false inverts the normals generated for the surface. This can be useful to illuminate the other side of the surface.
color = nothing, can be set to an Matrix{<: Union{Number, Colorant}} to color surface independent of the z component. If color=nothing, it defaults to color=z.

3D shading attributes

shading = Makie.automatic sets the lighting algorithm used. Options are NoShading (no lighting), FastShading (AmbientLight + PointLight) or MultiLightShading (Multiple lights, GLMakie only). Note that this does not affect RPRMakie.
diffuse::Vec3f = Vec3f(1.0) sets how strongly the red, green and blue channel react to diffuse (scattered) light.
specular::Vec3f = Vec3f(0.4) sets how strongly the object reflects light in the red, green and blue channels.
shininess::Real = 32.0 sets how sharp the reflection is.
backlight::Float32 = 0f0 sets a weight for secondary light calculation with inverted normals.
ssao::Bool = 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.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

surface!

No documentation found.

MakieCore.surface! is a Function.

# 1 method for generic function "surface!" from MakieCore:
 [1] surface!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

swap!

Swaps or rotates the layout positions of the given elements to their neighbor's.

text

text(positions; text, kwargs...)
text(x, y; text, kwargs...)
text(x, y, z; text, kwargs...)

Plots one or multiple texts passed via the text keyword. Text uses the PointBased conversion trait.

Attributes

Specific to `Text`

color=theme(scene, :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.
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.
align::Tuple{Union{Symbol, Real}, Union{Symbol, Real}} = (:left, :bottom) sets the alignment of the string w.r.t. position. Uses :left, :center, :right, :top, :bottom, :baseline or fractions.
font::Union{String, Vector{String}} = :regular sets the font for the string or each character.
justification::Union{Real, Symbol} = 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.
rotation::Union{Real, Quaternion} rotates text around the given position.
fontsize::Union{Real, Vec2f} sets the size of each character.
markerspace::Symbol = :pixel sets the space in which fontsize acts. See Makie.spaces() for possible inputs.
strokewidth::Real = 0 sets the width of the outline around a marker.
strokecolor::Union{Symbol, <:Colorant} = :black sets the color of the outline around a marker.
glowwidth::Real = 0 sets the size of a glow effect around the marker.
glowcolor::Union{Symbol, <:Colorant} = (:black, 0) sets the color of the glow effect.
word_wrap_width::Real = -1 specifies a linewidth limit for text. If a word overflows this limit, a newline is inserted before it. Negative numbers disable word wrapping.
transform_marker::Bool = 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.)

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

text!

No documentation found.

MakieCore.text! is a Function.

# 1 method for generic function "text!" from MakieCore:
 [1] text!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

theme

No documentation found.

MakieCore.theme is a Function.

# 8 methods for generic function "theme" from MakieCore:
 [1] theme(key::Symbol; default)
     @ Makie ~/work/Makie.jl/Makie.jl/src/theming.jl:238
 [2] theme(::Nothing)
     @ Makie ~/work/Makie.jl/Makie.jl/src/theming.jl:237
 [3] theme(::Nothing, key::Symbol; default)
     @ Makie ~/work/Makie.jl/Makie.jl/src/theming.jl:236
 [4] theme(x::AbstractScene)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:56
 [5] theme(x::AbstractScene, key; default)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:57
 [6] theme(x::Union{AbstractScene, MakieCore.ScenePlot}, args...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:55
 [7] theme(x::AbstractPlot)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/attributes.jl:166
 [8] theme(x::AbstractPlot, key; default)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:58

theme_black

No documentation found.

Makie.theme_black is a Function.

# 1 method for generic function "theme_black" from Makie:
 [1] theme_black()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_black.jl:1

theme_dark

No documentation found.

Makie.theme_dark is a Function.

# 1 method for generic function "theme_dark" from Makie:
 [1] theme_dark()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_dark.jl:1

theme_ggplot2

No documentation found.

Makie.theme_ggplot2 is a Function.

# 1 method for generic function "theme_ggplot2" from Makie:
 [1] theme_ggplot2()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_ggplot2.jl:1

theme_latexfonts

No documentation found.

Makie.theme_latexfonts is a Function.

# 1 method for generic function "theme_latexfonts" from Makie:
 [1] theme_latexfonts()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_latexfonts.jl:1

theme_light

No documentation found.

Makie.theme_light is a Function.

# 1 method for generic function "theme_light" from Makie:
 [1] theme_light()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_light.jl:1

theme_minimal

No documentation found.

Makie.theme_minimal is a Function.

# 1 method for generic function "theme_minimal" from Makie:
 [1] theme_minimal()
     @ ~/work/Makie.jl/Makie.jl/src/themes/theme_minimal.jl:1

thetalims!

thetalims!(ax::PolarAxis, thetamin, thetamax)

Sets the angular limits of a given PolarAxis.

tight_ticklabel_spacing!

tight_ticklabel_spacing!(ax::Axis)

Sets the space allocated for the xticklabels and yticklabels of the Axis to the minimum that is needed.

space = tight_ticklabel_spacing!(cb::Colorbar)

Sets the space allocated for the ticklabels of the Colorbar to the minimum that is needed and returns that value.

tight_xticklabel_spacing!

space = tight_xticklabel_spacing!(ax::Axis)

Sets the space allocated for the xticklabels of the Axis to the minimum that is needed and returns that value.

tight_yticklabel_spacing!

space = tight_yticklabel_spacing!(ax::Axis)

Sets the space allocated for the yticklabels of the Axis to the minimum that is needed and returns that value.

tightlimits!

tightlimits!(la::Axis)

Sets the autolimit margins to zero on all sides.

tightlimits!(la::Axis, sides::Union{Left, Right, Bottom, Top}...)

Sets the autolimit margins to zero on all given sides.

Example:

tightlimits!(laxis, Bottom())

timeseries

timeseries(x::Observable{{Union{Number, Point2}}})

Plots a sampled signal. Usage:

signal = Observable(1.0)
scene = timeseries(signal)
display(scene)
# @async is optional, but helps to continue evaluating more code
@async while isopen(scene)
    # aquire data from e.g. a sensor:
    data = rand()
    # update the signal
    signal[] = data
    # sleep/ wait for new data/ whatever...
    # It's important to yield here though, otherwise nothing will be rendered
    sleep(1/30)
end

timeseries!

No documentation found.

Makie.timeseries! is a Function.

# 1 method for generic function "timeseries!" from Makie:
 [1] timeseries!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

to_align

to_align(align[, error_prefix])

Converts the given align to a Vec2f. Can convert VecTypes{2} and two component Tuples with Real and Symbol elements.

To specify a custom error message you can add an error_prefix or use halign2num(value, error_msg) and valign2num(value, error_msg) respectively.

to_color

No documentation found.

Makie.to_color is a Function.

# 13 methods for generic function "to_color" from Makie:
  [1] to_color(scene::Scene, attribute_name, cycled::Cycled)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/blocks/axis.jl:695
  [2] to_color(c::Symbol)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:854
  [3] to_color(p::Makie.Palette)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:845
  [4] to_color(c::String)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:855
  [5] to_color(c::Nothing)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:851
  [6] to_color(c::Makie.ColorMapping)
     @ ~/work/Makie.jl/Makie.jl/src/colorsampler.jl:344
  [7] to_color(c::ColorTypes.Colorant)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:853
  [8] to_color(sampler::Sampler)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:1737
  [9] to_color(c::Real)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:852
 [10] to_color(p::Makie.AbstractPattern)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:858
 [11] to_color(c::AbstractArray{<:ColorTypes.Colorant, N}) where N
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:857
 [12] to_color(c::AbstractArray)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:856
 [13] to_color(c::Tuple{Any, Number})
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:859

to_colormap

to_colormap(b::AbstractVector)

An AbstractVector{T} with any object that to_color accepts.

to_colormap(cs::Union{String, Symbol})::Vector{RGBAf}

A Symbol/String naming the gradient. For more on what names are available please see: available_gradients(). For now, we support gradients from PlotUtils natively.

to_font

to_font(str::String)

Loads a font specified by str and returns a NativeFont object storing the font handle. A font can either be specified by a file path, such as "folder/with/fonts/font.otf", or by a (partial) name such as "Helvetica", "Helvetica Bold" etc.

to_fontsize

No documentation found.

Makie.to_fontsize is a Function.

# 4 methods for generic function "to_fontsize" from Makie:
 [1] to_fontsize(x::Vec2)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:1195
 [2] to_fontsize(x::AbstractVector{T}) where T<:(Vec2)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:1196
 [3] to_fontsize(x::AbstractVector{T}) where T<:Number
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:1194
 [4] to_fontsize(x::Number)
     @ ~/work/Makie.jl/Makie.jl/src/conversions.jl:1193

to_ndim

No documentation found.

Makie.to_ndim is a Function.

# 1 method for generic function "to_ndim" from Makie:
 [1] to_ndim(T::Type{<:Union{Tuple{Vararg{ET, N}}, StaticArraysCore.StaticArray{Tuple{N}, ET, 1}}}, vec::Union{Tuple{Vararg{T, N2}}, StaticArraysCore.StaticArray{Tuple{N2}, T, 1}} where T, fillval) where {N, ET, N2}
     @ ~/work/Makie.jl/Makie.jl/src/utilities/utilities.jl:242

to_rotation

rotation accepts:
to_rotation(b, quaternion)
to_rotation(b, tuple_float)
to_rotation(b, vec4)

to_value

to_value(x::Union{Any, AbstractObservable})

Extracts the value of an observable, and returns the object if it's not an observable!

to_vector

No documentation found.

Makie.to_vector is a Function.

# 3 methods for generic function "to_vector" from Makie:
 [1] to_vector(x::IntervalSets.ClosedInterval, len, T)
     @ ~/work/Makie.jl/Makie.jl/src/utilities/utilities.jl:289
 [2] to_vector(x::AbstractVector, len, T)
     @ ~/work/Makie.jl/Makie.jl/src/utilities/utilities.jl:281
 [3] to_vector(x::AbstractArray, len, T)
     @ ~/work/Makie.jl/Makie.jl/src/utilities/utilities.jl:282

to_world

No documentation found.

Makie.to_world is a Function.

# 3 methods for generic function "to_world" from Makie:
 [1] to_world(p::Vec{N, T}, prj_view_inv::StaticArraysCore.SMatrix{4, 4, T, 16} where T, cam_res::StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T}) where {N, T}
     @ ~/work/Makie.jl/Makie.jl/src/camera/projection_math.jl:272
 [2] to_world(p::StaticArraysCore.StaticArray{Tuple{N}, T, 1}, prj_view_inv::StaticArraysCore.SMatrix{4, 4, T, 16} where T, cam_res::StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T}) where {N, T}
     @ ~/work/Makie.jl/Makie.jl/src/camera/projection_math.jl:256
 [3] to_world(scene::Scene, point::T) where T<:(StaticArraysCore.StaticArray{Tuple{N}, T, 1} where {N, T})
     @ ~/work/Makie.jl/Makie.jl/src/camera/projection_math.jl:241

tooltip(position, string)
tooltip(x, y, string)

Creates a tooltip pointing at position displaying the given string

Attributes

Generic

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
space::Symbol = :data sets the transformation space for positions of markers. See Makie.spaces() for possible inputs.

Tooltip specific

offset = 10 sets the offset between the given position and the tip of the triangle pointing at that position.
placement = :above sets where the tooltipü should be placed relative to position. Can be :above, :below, :left, :right.
align = 0.5 sets the alignment of the tooltip relative position. With align = 0.5 the tooltip is centered above/below/left/right the position.
backgroundcolor = :white sets the background color of the tooltip.
triangle_size = 10 sets the size of the triangle pointing at position.
outline_color = :black sets the color of the tooltip outline.
outline_linewidth = 2f0 sets the linewidth of the tooltip outline.
outline_linestyle = nothing sets the linestyle of the tooltip outline.
textpadding = (4, 4, 4, 4) sets the padding around text in the tooltip. This is given as (left, right, bottom top) offsets.
textcolor = theme(scene, :textcolor) sets the text color.
fontsize = 16 sets the text size.
font = theme(scene, :font) sets the font.
strokewidth = 0: Gives text an outline if set to a positive value.
strokecolor = :white sets the text outline color.
justification = :left sets whether text is aligned to the :left, :center or :right within its bounding box.

tooltip!

No documentation found.

Makie.tooltip! is a Function.

# 1 method for generic function "tooltip!" from Makie:
 [1] tooltip!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

top

No documentation found.

Makie.top is a Function.

# 1 method for generic function "top" from Makie:
 [1] top(rect::Rect2)
     @ ~/work/Makie.jl/Makie.jl/src/makielayout/geometrybasics_extension.jl:5

translate!

translate!(t::Transformable, xyz::VecTypes)
translate!(t::Transformable, xyz...)

Apply an absolute translation to the given Transformable (a Scene or Plot), translating it to x, y, z.

translate!(Accum, t::Transformable, xyz...)

Translate the given Transformable (a Scene or Plot), relative to its current position.

translate_cam!

translate_cam!(scene, cam::Camera3D, v::Vec3)

Translates the camera by the given vector in camera space, i.e. by v[1] to the right, v[2] to the top and v[3] forward.

Note that this method reacts to fix_x_key etc. If any of those keys are pressed the translation will be restricted to act in these directions.

translate_cam!(scene::Scene, translation::VecTypes)

Translate the camera by a translation vector given in camera space.

translated

No documentation found.

Makie.translated is a Function.

# 2 methods for generic function "translated" from Makie:
 [1] translated(scene::Scene; kw_args...)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/transformation.jl:40
 [2] translated(scene::Scene, translation...)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/transformation.jl:34

translation

No documentation found.

Makie.translation is a Function.

# 1 method for generic function "translation" from Makie:
 [1] translation(t::MakieCore.Transformable)
     @ ~/work/Makie.jl/Makie.jl/src/layouting/transformation.jl:115

tricontourf

tricontourf(triangles::Triangulation, zs; kwargs...)
tricontourf(xs, ys, zs; kwargs...)

Plots a filled tricontour of the height information in zs at the horizontal positions xs and vertical positions ys. A Triangulation from DelaunayTriangulation.jl can also be provided instead of xs and ys for specifying the triangles, otherwise an unconstrained triangulation of xs and ys is computed.

Attributes

Specific to `Tricontourf`

levels = 10 can be either an Int which results in n bands delimited by n+1 equally spaced levels, or it can be an AbstractVector{<:Real} that lists n consecutive edges from low to high, which result in n-1 bands.
mode = :normal sets the way in which a vector of levels is interpreted, if it's set to :relative, each number is interpreted as a fraction between the minimum and maximum values of zs. For example, levels = 0.1:0.1:1.0 would exclude the lower 10% of data.
extendlow = nothing. This sets the color of an optional additional band from minimum(zs) to the lowest value in levels. If it's :auto, the lower end of the colormap is picked and the remaining colors are shifted accordingly. If it's any color representation, this color is used. If it's nothing, no band is added.
extendhigh = nothing. This sets the color of an optional additional band from the highest value of levels to maximum(zs). If it's :auto, the high end of the colormap is picked and the remaining colors are shifted accordingly. If it's any color representation, this color is used. If it's nothing, no band is added.
triangulation = DelaunayTriangulation(). The mode with which the points in xs and ys are triangulated. Passing DelaunayTriangulation() performs a Delaunay triangulation. You can also pass a preexisting triangulation as an AbstractMatrix{<:Int} with size (3, n), where each column specifies the vertex indices of one triangle, or as a Triangulation from DelaunayTriangulation.jl.

Generic

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = false adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
color sets the color of the plot. It can be given as a named color Symbol or a Colors.Colorant. Transparency can be included either directly as an alpha value in the Colorant or as an additional float in a tuple (color, alpha). The color can also be set for each scattered marker by passing a Vector of colors or be used to index the colormap by passing a Real number or Vector{<: Real}.
colormap::Union{Symbol, Vector{<:Colorant}} = :viridis sets the colormap from which the band colors are sampled.
colorscale::Function = identity color transform function.

Attributes

Available attributes and their defaults for Plot{Makie.tricontourf} are:

  colormap       :viridis
  colorscale     identity
  edges          "nothing"
  extendhigh     "nothing"
  extendlow      "nothing"
  inspectable    true
  levels         10
  mode           :normal
  nan_color      :transparent
  transparency   false
  triangulation  Makie.DelaunayTriangulation()

tricontourf!

No documentation found.

Makie.tricontourf! is a Function.

# 1 method for generic function "tricontourf!" from Makie:
 [1] tricontourf!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

trim!

trim!(gl::GridLayout)

Remove empty rows and columns from gl.

triplot

triplot(x, y; kwargs...)
triplot(positions; kwargs...)
triplot(triangles::Triangulation; kwargs...)

Plots a triangulation based on the provided position or Triangulation from DelaunayTriangulation.jl.

Attributes

show_points = false determines whether to plot the individual points. Note that this will only plot points included in the triangulation.
show_convex_hull = false determines whether to plot the convex hull.
show_ghost_edges = false determines whether to plot the ghost edges.
show_constrained_edges = false determines whether to plot the constrained edges.
recompute_centers = false determines whether to recompute the representative points for the ghost edge orientation. Note that this will mutate tri.representative_point_list directly.
markersize = 12 sets the size of the points.
marker = :circle sets the shape of the points.
markercolor = :black sets the color of the points.
strokecolor = :black sets the color of triangle edges.
strokewidth = 1 sets the linewidth of triangle edges.
linestyle = :solid sets the linestyle of triangle edges.
triangle_color = (:white, 0.0) sets the color of the triangles.
convex_hull_color = :red sets the color of the convex hull.
convex_hull_linestyle = :dash sets the linestyle of the convex hull.
convex_hull_linewidth = 1 sets the width of the convex hull.
ghost_edge_color = :blue sets the color of the ghost edges.
ghost_edge_linestyle = :solid sets the linestyle of the ghost edges.
ghost_edge_linewidth = 1 sets the width of the ghost edges.
ghost_edge_extension_factor = 0.1 sets the extension factor for the rectangle that the exterior ghost edges are extended onto.
bounding_box::Union{Automatic, Rect2, Tuple} = automatic: Sets the bounding box for truncating ghost edges which can be a Rect2 (or BBox) or a tuple of the form (xmin, xmax, ymin, ymax). By default, the rectangle will be given by [a - eΔx, b + eΔx] × [c - eΔy, d + eΔy] where e is the ghost_edge_extension_factor, Δx = b - a and Δy = d - c are the lengths of the sides of the rectangle, and [a, b] × [c, d] is the bounding box of the points in the triangulation.
constrained_edge_color = :magenta sets the color of the constrained edges.
constrained_edge_linestyle = :solid sets the linestyle of the constrained edges.
constrained_edge_linewidth = 1 sets the width of the constrained edges.

triplot!

No documentation found.

Makie.triplot! is a Function.

# 1 method for generic function "triplot!" from Makie:
 [1] triplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

unicode_input

Registers a callback for keyboard unicode input. returns an Observable{Vector{Char}}, containing the pressed char. Is empty, if no key is pressed. GLFW Docs

update_cam!

update_cam!(scene::SceneLike, area)

Updates the camera for the given scene to cover the given area in 2d.

update_cam!(scene::SceneLike)

Updates the camera for the given scene to cover the limits of the Scene. Useful when using the Observable pipeline.

update_cam!(scene, cam::Camera3D, ϕ, θ[, radius])

Set the camera position based on two angles 0 ≤ ϕ ≤ 2π and -pi/2 ≤ θ ≤ pi/2 and an optional radius around the current cam.lookat[].

update_cam!(scene::Scene, eyeposition, lookat, up = Vec3f(0, 0, 1))

Updates the camera's controls to point to the specified location.

update_theme!

update_theme!(with_theme::Theme; kwargs...)

Update the current theme incrementally. This means that only the keys given in with_theme or through keyword arguments are changed, the rest is left intact. Nested attributes are either also updated incrementally, or replaced if they are not attributes in the new theme.

Example

To change the default colormap to :greys, you can pass that attribute as a keyword argument to update_theme! as demonstrated below.

update_theme!(colormap=:greys)

This can also be achieved by passing an object of types Attributes or Theme as the first and only positional argument:

update_theme!(Attributes(colormap=:greys))
update_theme!(Theme(colormap=:greys))

used_attributes

used_attributes(args...) = ()

Function used to indicate what keyword args one wants to get passed in convert_arguments. Those attributes will not be forwarded to the backend, but only used during the conversion pipeline. Usage:

    struct MyType end
    used_attributes(::MyType) = (:attribute,)
    function convert_arguments(x::MyType; attribute = 1)
        ...
    end
    # attribute will get passed to convert_arguments
    # without keyword_verload, this wouldn't happen
    plot(MyType, attribute = 2)
    #You can also use the convenience macro, to overload convert_arguments in one step:
    @keywords convert_arguments(x::MyType; attribute = 1)
        ...
    end

vgrid!

vbox!(content::Vararg; kwargs...)

Creates a single-column GridLayout with all elements contained in content placed from top to bottom.

viewport

viewport(scene::Scene)

Gets the viewport of the scene in device independent units as an Observable{Rect2{Int}}.

violin

violin(x, y; kwargs...)

Draw a violin plot.

Arguments

x: positions of the categories
y: variables whose density is computed

Keywords

weights: vector of statistical weights (length of data). By default, each observation has weight 1.
orientation=:vertical: orientation of the violins (:vertical or :horizontal)
width=1: width of the box before shrinking
gap=0.2: shrinking factor, width -> width * (1 - gap)
show_median=false: show median as midline
side=:both: specify :left or :right to only plot the violin on one side
scale=:width: scale density by area (:area), count (:count), or width (:width).
datalimits: specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema)

violin!

No documentation found.

Makie.violin! is a Function.

# 1 method for generic function "violin!" from Makie:
 [1] violin!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

vlines

vlines(xs; ymin = 0.0, ymax = 1.0, attrs...)

Create vertical lines across a Scene with 2D projection. The lines will be placed at xs in data coordinates and ymin to ymax in scene coordinates (0 to 1). All three of these can have single or multiple values because they are broadcast to calculate the final line segments.

All style attributes are the same as for LineSegments.

vlines!

No documentation found.

Makie.vlines! is a Function.

# 1 method for generic function "vlines!" from Makie:
 [1] vlines!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

volume

volume(volume_data)
volume(x, y, z, volume_data)

Plots a volume, with optional physical dimensions x, y, z. Available algorithms are:

:iso => IsoValue
:absorption => Absorption
:mip => MaximumIntensityProjection
:absorptionrgba => AbsorptionRGBA
:additive => AdditiveRGBA
:indexedabsorption => IndexedAbsorptionRGBA

Attributes

Specific to `Volume`

algorithm::Union{Symbol, RaymarchAlgorithm} = :mip sets the volume algorithm that is used.
isorange::Real = 0.05 sets the range of values picked up by the IsoValue algorithm.
isovalue = 0.5 sets the target value for the IsoValue algorithm.
interpolate::Bool = true sets whether the volume data should be sampled with interpolation.

3D shading attributes

shading = Makie.automatic sets the lighting algorithm used. Options are NoShading (no lighting), FastShading (AmbientLight + PointLight) or MultiLightShading (Multiple lights, GLMakie only). Note that this does not affect RPRMakie.
diffuse::Vec3f = Vec3f(1.0) sets how strongly the red, green and blue channel react to diffuse (scattered) light.
specular::Vec3f = Vec3f(0.4) sets how strongly the object reflects light in the red, green and blue channels.
shininess::Real = 32.0 sets how sharp the reflection is.
backlight::Float32 = 0f0 sets a weight for secondary light calculation with inverted normals.
ssao::Bool = 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.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

Generic attributes

visible::Bool = true sets whether the plot will be rendered or not.
overdraw::Bool = false sets whether the plot will draw over other plots. This specifically means ignoring depth checks in GL backends.
transparency::Bool = false adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.
fxaa::Bool = true adjusts whether the plot is rendered with fxaa (anti-aliasing).
inspectable::Bool = true sets whether this plot should be seen by DataInspector.
depth_shift::Float32 = 0f0 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).
model::Makie.Mat4f sets a model matrix for the plot. This replaces adjustments made with translate!, rotate! and scale!.
space::Symbol = :data sets the transformation space for box encompassing the volume plot. See Makie.spaces() for possible inputs.

volume!

No documentation found.

MakieCore.volume! is a Function.

# 1 method for generic function "volume!" from MakieCore:
 [1] volume!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

volumeslices

VolumeSlices

volumeslices(x, y, z, v)

Draws heatmap slices of the volume v

Attributes

Available attributes and their defaults for Plot{Makie.volumeslices} are:

  alpha           1.0
  bbox_color      RGBA{Float32}(0.5f0,0.5f0,0.5f0,0.5f0)
  bbox_visible    true
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  depth_shift     0.0f0
  highclip        MakieCore.Automatic()
  inspectable     true
  interpolate     false
  linewidth       0.0
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  transparency    false
  visible         true

volumeslices!

No documentation found.

Makie.volumeslices! is a Function.

# 1 method for generic function "volumeslices!" from Makie:
 [1] volumeslices!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

voronoiplot

voronoiplot(x, y, values; kwargs...)
voronoiplot(values; kwargs...)
voronoiplot(x, y; kwargs...)
voronoiplot(positions; kwargs...)
voronoiplot(vorn::VoronoiTessellation; kwargs...)

Generates and plots a Voronoi tessalation from heatmap- or point-like data. The tessellation can also be passed directly as a VoronoiTessellation from DelaunayTriangulation.jl.

Attributes

show_generators = true determines whether to plot the individual generators.
markersize = 12 sets the size of the points.
marker = :circle sets the shape of the points.
markercolor = :black sets the color of the points.
strokecolor = :black sets the strokecolor of the polygons.
strokewidth = 1 sets the width of the polygon stroke.
color = automatic sets the color of the polygons. If automatic, the polygons will be individually colored according to the colormap.
unbounded_edge_extension_factor = 0.1 sets the extension factor for the unbounded edges, used in DelaunayTriangulation.polygon_bounds.
clip::Union{Automatic, Rect2, Circle, Tuple} = automatic sets the clipping area for the generated polygons which can be a Rect2 (or BBox), Tuple with entries (xmin, xmax, ymin, ymax) or as a Circle. Anything outside the specified area will be removed. If the clip is not set it is automatically determined using unbounded_edge_extension_factor as a Rect.

Color attributes

colormap::Union{Symbol, Vector{<:Colorant}} = :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().
colorscale::Function = identity 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.
colorrange::Tuple{<:Real, <:Real} sets the values representing the start and end points of colormap.
nan_color::Union{Symbol, <:Colorant} = RGBAf(0,0,0,0) sets a replacement color for color = NaN.
lowclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value below the colorrange.
highclip::Union{Nothing, Symbol, <:Colorant} = nothing sets a color for any value above the colorrange.
alpha = 1.0 sets the alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

voronoiplot!

No documentation found.

Makie.voronoiplot! is a Function.

# 1 method for generic function "voronoiplot!" from Makie:
 [1] voronoiplot!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

vspan

vspan(xs_low, xs_high; ymin = 0.0, ymax = 1.0, attrs...)
vspan(xs_lowhigh; ymin = 0.0, ymax = 1.0, attrs...)

Create vertical bands spanning across a Scene with 2D projection. The bands will be placed from xs_low to xs_high in data coordinates and ymin to ymax in scene coordinates (0 to 1). All four of these can have single or multiple values because they are broadcast to calculate the final spans. Both bounds can be passed together as an interval xs_lowhigh.

All style attributes are the same as for Poly.

vspan!

No documentation found.

Makie.vspan! is a Function.

# 1 method for generic function "vspan!" from Makie:
 [1] vspan!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

waterfall

waterfall(x, y; kwargs...)

Plots a waterfall chart to visualize individual positive and negative components that add up to a net result as a barplot with stacked bars next to each other.

Attributes

Available attributes and their defaults for Plot{Makie.waterfall} are:

  cycle            [:color => :patchcolor]
  direction_color  :white
  dodge            MakieCore.Automatic()
  dodge_gap        0.03
  final_color      RGBA{Float64}(0.8980392156862745,0.8980392156862745,0.8980392156862745,0.5)
  final_dodge_gap  0
  final_gap        MakieCore.Automatic()
  gap              0.2
  marker_neg       :dtriangle
  marker_pos       :utriangle
  n_dodge          MakieCore.Automatic()
  show_direction   false
  show_final       false
  stack            MakieCore.Automatic()
  width            MakieCore.Automatic()

Furthermore the same attributes as for barplot are supported.

waterfall!

No documentation found.

Makie.waterfall! is a Function.

# 1 method for generic function "waterfall!" from Makie:
 [1] waterfall!(args...; kw...)
     @ ~/work/Makie.jl/Makie.jl/MakieCore/src/recipes.jl:176

width

No documentation found.

GeometryBasics.width is a Function.

# 1 method for generic function "width" from GeometryBasics:
 [1] width(prim::GeometryBasics.HyperRectangle)
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/primitives/rectangles.jl:186

widths

No documentation found.

GeometryBasics.widths is a Function.

# 4 methods for generic function "widths" from GeometryBasics:
 [1] widths(scene::Scene)
     @ Makie ~/work/Makie.jl/Makie.jl/src/scenes.jl:342
 [2] widths(x::AbstractRange)
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/geometry_primitives.jl:4
 [3] widths(c::GeometryBasics.HyperSphere{N, T}) where {N, T}
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/primitives/spheres.jl:28
 [4] widths(prim::GeometryBasics.HyperRectangle)
     @ ~/.julia/packages/GeometryBasics/ebXl0/src/primitives/rectangles.jl:184

window_area

No documentation found.

Makie.window_area is a Function.

# 2 methods for generic function "window_area" from Makie:
 [1] window_area(scene::Scene, screen::GLMakie.Screen)
     @ GLMakie ~/work/Makie.jl/Makie.jl/GLMakie/src/events.jl:40
 [2] window_area(scene, native_window)
     @ ~/work/Makie.jl/Makie.jl/src/interaction/events.jl:3

window_open

Returns a signal, which is true as long as the window is open. returns Observable{Bool}GLFW Docs

wireframe

wireframe(x, y, z)
wireframe(positions)
wireframe(mesh)

Draws a wireframe, either interpreted as a surface or as a mesh.

Attributes

Available attributes and their defaults for Wireframe are:

  alpha           1.0
  color           :black
  colormap        :viridis
  colorrange      MakieCore.Automatic()
  colorscale      identity
  cycle           [:color]
  depth_shift     -1.0f-5
  highclip        MakieCore.Automatic()
  inspectable     true
  linestyle       "nothing"
  linewidth       1.5
  lowclip         MakieCore.Automatic()
  nan_color       :transparent
  overdraw        false
  space           :data
  ssao            false
  transparency    false
  visible         true

wireframe!

See wireframe.

with_theme

with_theme(f, theme = Theme(); kwargs...)

Calls f with theme temporarily activated. Attributes in theme can be overridden or extended with kwargs. The previous theme is always restored afterwards, no matter if f succeeds or fails.

Example:

my_theme = Theme(size = (500, 500), color = :red)
with_theme(my_theme, color = :blue, linestyle = :dashed) do
    scatter(randn(100, 2))
end

with_updates_suspended

with_updates_suspended(f::Function, gl::GridLayout; update = true)

Disable layout updates for gl and call the function f. If update is true, force a layout update after f returns.

xlabel!

xlabel!([scene,] xlabel)

Set the x-axis label for the given Scene. Defaults to using the current Scene.

xlims!

xlims!(ax, low, high)
xlims!(ax; low = nothing, high = nothing)
xlims!(ax, (low, high))
xlims!(ax, low..high)

Set the x-axis limits of axis ax to low and high or a tuple xlims = (low,high). If the limits are ordered high-low, the axis orientation will be reversed. If a limit is nothing it will be determined automatically from the plots in the axis.

xlims!(low, high)
xlims!(; low = nothing, high = nothing)

Set the x-axis limits of the current axis to low and high. If the limits are ordered high-low, this reverses the axis orientation. A limit set to nothing will be determined automatically from the plots in the axis.

xlims!(ax = current_axis())

Reset the x-axis limits to be determined automatically from the plots in the axis.

xticklabels

xticklabels(scene)

Returns all the x-axis tick labels. See also ticklabels.

xtickrange

xtickrange(scene)

Returns the tick range along the x-axis. See also tickranges.

xtickrotation

xtickrotation(scene)

Returns the rotation of tick labels along the x-axis. See also tickrotations

xtickrotation!

xtickrotation!([scene,] xangle)

Set the rotation of tick labels along the x-axis. See also tickrotations!.

xticks!

xticks!([scene,]; xtickrange=xtickrange(scene), xticklabels=xticklabel(scene))

Set the tick labels and range along the x-axis. See also ticks!.

ylabel!

ylabel!([scene,] ylabel)

Set the y-axis label for the given Scene. Defaults to using the current Scene.

ylims!

ylims!(ax, low, high)
ylims!(ax; low = nothing, high = nothing)
ylims!(ax, (low, high))
ylims!(ax, low..high)

Set the y-axis limits of axis ax to low and high or a tuple ylims = (low,high). If the limits are ordered high-low, the axis orientation will be reversed. If a limit is nothing it will be determined automatically from the plots in the axis.

ylims!(low, high)
ylims!(; low = nothing, high = nothing)

Set the y-axis limits of the current axis to low and high. If the limits are ordered high-low, this reverses the axis orientation. A limit set to nothing will be determined automatically from the plots in the axis.

ylims!(ax = current_axis())

Reset the y-axis limits to be determined automatically from the plots in the axis.

yticklabels

yticklabels(scene)

Returns all the y-axis tick labels. See also ticklabels.

ytickrange

ytickrange(scene)

Returns the tick range along the y-axis. See also tickranges.

ytickrotation

ytickrotation(scene)

Returns the rotation of tick labels along the y-axis. See also tickrotations

ytickrotation!

ytickrotation!([scene,] yangle)

Set the rotation of tick labels along the y-axis. See also tickrotations!.

yticks!

yticks!([scene,]; ytickrange=ytickrange(scene), yticklabels=yticklabel(scene))

Set the tick labels and range along all the y-axis. See also ticks!.

zlabel!

zlabel!([scene,] zlabel)

Set the z-axis label for the given Scene. Defaults to using the current Scene.

Warning

The Scene must have an Axis3D. If not, then this function will error.

zlims!

zlims!(ax, low, high)
zlims!(ax; low = nothing, high = nothing)
zlims!(ax, (low, high))
zlims!(ax, low..high)

Set the z-axis limits of axis ax to low and high or a tuple zlims = (low,high). If the limits are ordered high-low, the axis orientation will be reversed. If a limit is nothing it will be determined automatically from the plots in the axis.

zlims!(low, high)
zlims!(; low = nothing, high = nothing)

Set the z-axis limits of the current axis to low and high. If the limits are ordered high-low, this reverses the axis orientation. A limit set to nothing will be determined automatically from the plots in the axis.

zlims!(ax = current_axis())

Reset the z-axis limits to be determined automatically from the plots in the axis.

zoom!

zoom!(scene, cam::Camera3D, zoom_step[, cad = false, zoom_shift_lookat = false])

Zooms the camera in or out based on the multiplier zoom_step. A zoom_step of 1.0 is neutral, larger zooms out and lower zooms in.

If cad = true zooming will also apply a rotation based on how far the cursor is from the center of the scene. If zoom_shift_lookat = true and projectiontype = Orthographic zooming will keep the data under the cursor at the same screen space position.

zoom!(scene, point, zoom_step, shift_lookat::Bool)

Zooms the camera of scene in towards point by a factor of zoom_step. A positive zoom_step zooms in while a negative zoom_step zooms out.

zticklabels

zticklabels(scene)

Returns all the z-axis tick labels. See also ticklabels.

ztickrange

ztickrange(scene)

Returns the tick range along the z-axis. See also tickranges.

ztickrotation

ztickrotation(scene)

Returns the rotation of tick labels along the z-axis. See also tickrotations

ztickrotation!

ztickrotation!([scene,] zangle)

Set the rotation of tick labels along the z-axis. See also tickrotations!.

zticks!

zticks!([scene,]; ztickranges=ztickrange(scene), zticklabels=zticklabel(scene))

Set the tick labels and range along all z-axis. See also ticks!.

These docs were autogenerated using Makie: v0.20.10, GLMakie: v0.9.11, CairoMakie: v0.11.12, WGLMakie: v0.9.10

API

Examples

Example:

before

after

Plot Recipes in Makie

Type recipes

Full recipes with the @recipe macro

Summary

Supertype Hierarchy

Summary

Supertype Hierarchy

Summary

Subtypes

Summary

Subtypes

Supertype Hierarchy

Summary

Subtypes

Supertype Hierarchy

Summary

Fields

Examples

Summary

Fields

Example

Summary

Supertype Hierarchy

Summary

Supertype Hierarchy

Summary

Supertype Hierarchy

Fields

Summary

Fields

Supertype Hierarchy

Settings

Controls

Other kwargs

Constructors

Summary

Fields

Summary

Subtypes

Summary

Fields

Summary

Keyword Arguments:

Summary

Supertype Hierarchy

Fields

Summary

Supertype Hierarchy

Summary

Fields

Summary

Fields

Summary

Fields

Summary

Fields

Summary

Supertype Hierarchy

Summary

Supertype Hierarchy

Summary

Fields

Summary

Supertype Hierarchy

Summary

Subtypes

Summary

Fields

Summary

Fields

Supertype Hierarchy

Summary

Fields

Supertype Hierarchy

Summary

Plot Recipes in `Makie`

Full recipes with the `@recipe` macro