Skip to content

API

# Makie.ABLinesType.

ABLines is the plot type associated with plotting function ablines. Check the docstring for ablines for further information.

source


# Makie.AbsoluteType.
julia
Absolute

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

source


# Makie.AccumType.
julia
Accum

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

source


# Makie.AmbientLightType.
julia
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

source


# Makie.AnnotationsType.

Annotations is the plot type associated with plotting function annotations. Check the docstring for annotations for further information.

source


# Makie.ArcType.

Arc is the plot type associated with plotting function arc. Check the docstring for arc for further information.

source


# Makie.AxisType.

Makie.Axis <: Block

A 2D axis which can be plotted into.

Constructors

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

Attributes

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

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

source


# Makie.Axis3Type.

Makie.Axis3 <: Block

No docstring defined.

Attributes

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

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

source


# Makie.BandType.

Band is the plot type associated with plotting function band. Check the docstring for band for further information.

source


# Makie.BarPlotType.

BarPlot is the plot type associated with plotting function barplot. Check the docstring for barplot for further information.

source


# Makie.BezierPathType.
julia
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.

source


# Makie.BezierPathMethod.
julia
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:

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

source


# Makie.BoxType.

Makie.Box <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.BoxPlotType.

BoxPlot is the plot type associated with plotting function boxplot. Check the docstring for boxplot for further information.

source


# Makie.BracketType.

Bracket is the plot type associated with plotting function bracket. Check the docstring for bracket for further information.

source


# Makie.ButtonType.

Makie.Button <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.CameraType.
julia
Camera(pixel_area)

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

Fields

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

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

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

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

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

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

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

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

  • calculated_values::Dict{Symbol, Observable}

source


# Makie.Camera3DMethod.
julia
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).

source


# Makie.CategoricalType.
julia
Categorical(colormaplike)

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

Example:

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

Warning

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

source


# Makie.ClosePathType.
julia
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.

source


# Makie.ColorbarType.

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

julia
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 ?Makie.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

source


# Makie.ContourType.

Contour is the plot type associated with plotting function contour. Check the docstring for contour for further information.

source


# Makie.Contour3dType.

Contour3d is the plot type associated with plotting function contour3d. Check the docstring for contour3d for further information.

source


# Makie.ContourfType.

Contourf is the plot type associated with plotting function contourf. Check the docstring for contourf for further information.

source


# Makie.CrossBarType.

CrossBar is the plot type associated with plotting function crossbar. Check the docstring for crossbar for further information.

source


# Makie.CurveToType.
julia
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.

source


# Makie.CycledType.
julia
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.

source


# Makie.DataInspectorMethod.
julia
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

source


# Makie.DataShaderType.

DataShader is the plot type associated with plotting function datashader. Check the docstring for datashader for further information.

source


# Makie.DensityType.

Density is the plot type associated with plotting function density. Check the docstring for density for further information.

source


# Makie.DirectionalLightType.
julia
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

source


# Makie.ECDFPlotType.

ECDFPlot is the plot type associated with plotting function ecdfplot. Check the docstring for ecdfplot for further information.

source


# Makie.EllipticalArcType.
julia
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.

source


# Makie.EllipticalArcMethod.
julia
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.

source


# Makie.EnvironmentLightType.
julia
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

source


# Makie.ErrorbarsType.

Errorbars is the plot type associated with plotting function errorbars. Check the docstring for errorbars for further information.

source


# Makie.EventsType.

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.

source


# Makie.ExclusivelyType.
julia
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, &, |, !

source


# Makie.FigureMethod.
julia
Figure(; [figure_padding,] kwargs...)

Construct a Figure which allows to place Blocks like Axis, Colorbar and Legend inside. The outer padding of the figure (the distance of the content to the edges) can be set by passing either one number or a tuple of four numbers for left, right, bottom and top paddings via the figure_padding keyword.

All other keyword arguments such as size and backgroundcolor are forwarded to the Scene owned by the figure which acts as the container for all other visual objects.

source


# Makie.HLinesType.

HLines is the plot type associated with plotting function hlines. Check the docstring for hlines for further information.

source


# Makie.HSpanType.

HSpan is the plot type associated with plotting function hspan. Check the docstring for hspan for further information.

source


# Makie.HexbinType.

Hexbin is the plot type associated with plotting function hexbin. Check the docstring for hexbin for further information.

source


# Makie.HistType.

Hist is the plot type associated with plotting function hist. Check the docstring for hist for further information.

source


# Makie.IntervalSliderType.

Makie.IntervalSlider <: Block

No docstring defined.

Attributes

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

alignmode, color_active, color_active_dimmed, color_inactive, halign, height, horizontal, interval, linewidth, range, snap, startvalues, tellheight, tellwidth, valign, width

source


# Makie.IntervalsBetweenType.
julia
IntervalsBetween(n::Int, mirror::Bool = true)

Indicates to create n-1 minor ticks between every pair of adjacent major ticks.

source


# Makie.LSceneType.

Makie.LScene <: Block

No docstring defined.

Attributes

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

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

source


# Makie.LabelType.

Makie.Label <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.LegendType.
julia
Legend(fig_or_scene, axis::Union{Axis, Scene, LScene}, title = nothing; merge = false, unique = false, kwargs...)

Create a single-group legend with all plots from axis that have the attribute label set.

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.

source


# Makie.LegendType.
julia
Legend(
    fig_or_scene,
    contents::AbstractArray,
    labels::AbstractArray,
    title = nothing;
    kwargs...)

Create a legend from contents and labels where each label is associated to one content element. A content element can be an AbstractPlot, an array of AbstractPlots, a LegendElement, or any other object for which the legendelements method is defined.

source


# Makie.LegendType.

Makie.Legend <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.LegendMethod.
julia
Legend(
    fig_or_scene,
    contentgroups::AbstractVector{<:AbstractVector},
    labelgroups::AbstractVector{<:AbstractVector},
    titles::AbstractVector;
    kwargs...)

Create a multi-group legend from contentgroups, labelgroups and titles. Each group from contentgroups and labelgroups is associated with one title from titles (a title can be nothing to hide it).

Within each group, each content element is associated with one label. A content element can be an AbstractPlot, an array of AbstractPlots, a LegendElement, or any other object for which the legendelements method is defined.

source


# Makie.LineToType.
julia
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.

source


# Makie.LinearTicksType.

LinearTicks with ideally a number of n_ideal tick marks.

source


# Makie.LinestyleType.
julia
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 specifying the boundaries of the dashes in the line. Values 1 and 2 demarcate the first dash, values 2 and 3 the first gap, and so on. This means that usually, a pattern should have an odd number of values so that there's always a gap after a dash.

Here's an example in ASCII code. If we specify [0, 3, 6, 11, 16] then we get the following pattern:

#  0  3   6   11   16  3  6   11
#   ---   -----     ---   -----

source


# Makie.LogTicksType.
julia
LogTicks{T}(linear_ticks::T)

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

source


# Makie.MenuType.

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

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

Examples

Menu with string entries, second preselected:

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

Menu with two-element entries, label and function:

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

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

Attributes

(type ?Makie.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

source


# Makie.MouseEventType.
julia
MouseEvent

Describes a mouse state change. Fields:

  • type: MouseEventType

  • t: Time of the event

  • data: Mouse position in data coordinates

  • px: Mouse position in px relative to scene origin

  • prev_t: Time of previous event

  • prev_data: Previous mouse position in data coordinates

  • prev_px: Previous mouse position in data coordinates

source


# Makie.MoveToType.
julia
MoveTo(p::VecTypes)
MoveTo(x::Real, y::Real)

A path command for use within a BezierPath which starts a new subpath at the given point.

source


# Makie.MultiplesTicksType.

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

source


# Makie.PieType.

Pie is the plot type associated with plotting function pie. Check the docstring for pie for further information.

source


# Makie.PlotSpecType.
julia
PlotSpec(plottype, args...; kwargs...)

Object encoding positional arguments (args), a NamedTuple of attributes (kwargs) as well as plot type P of a basic plot.

source


# Makie.PointLightType.
julia
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

source


# Makie.PolarAxisType.

Makie.PolarAxis <: Block

No docstring defined.

Attributes

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

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

source


# Makie.QQNormType.

QQNorm is the plot type associated with plotting function qqnorm. Check the docstring for qqnorm for further information.

source


# Makie.QQPlotType.

QQPlot is the plot type associated with plotting function qqplot. Check the docstring for qqplot for further information.

source


# Makie.RainCloudsType.

RainClouds is the plot type associated with plotting function rainclouds. Check the docstring for rainclouds for further information.

source


# Makie.RangebarsType.

Rangebars is the plot type associated with plotting function rangebars. Check the docstring for rangebars for further information.

source


# Makie.RectLightType.
julia
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

source


# Makie.ReverseType.

Reverses the attribute T upon conversion

source


# Makie.ReversibleScaleType.
julia
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

source


# Makie.ScatterLinesType.

ScatterLines is the plot type associated with plotting function scatterlines. Check the docstring for scatterlines for further information.

source


# Makie.SceneType.
julia
Scene TODO document this

Constructors

Fields

  • parent: The parent of the Scene; if it is a top-level Scene, parent == nothing.

  • events: Events associated with the Scene.

  • viewport: The current pixel area of the Scene.

  • clear: Whether the scene should be cleared.

  • camera: The Camera associated with the Scene.

  • camera_controls: The controls for the camera of the Scene.

  • transformation: The Transformation of the Scene.

  • float32convert: A transformation rescaling data to a Float32-save range.

  • plots: The plots contained in the Scene.

  • theme

  • children: Children of the Scene inherit its transformation.

  • current_screens: The Screens which the Scene is displayed to.

  • backgroundcolor

  • visible

  • ssao

  • lights

  • deregister_callbacks

  • cycler

  • conversions

source


# Makie.SceneSpaceType.

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

source


# Makie.SeriesType.

Series is the plot type associated with plotting function series. Check the docstring for series for further information.

source


# Makie.SliderType.

Makie.Slider <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.SliderGridType.

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

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

Examples

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

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

Attributes

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

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

source


# Makie.SpotLightType.
julia
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

source


# Makie.SpyType.

Spy is the plot type associated with plotting function spy. Check the docstring for spy for further information.

source


# Makie.StairsType.

Stairs is the plot type associated with plotting function stairs. Check the docstring for stairs for further information.

source


# Makie.StemType.

Stem is the plot type associated with plotting function stem. Check the docstring for stem for further information.

source


# Makie.StepHistType.

StepHist is the plot type associated with plotting function stephist. Check the docstring for stephist for further information.

source


# Makie.StreamPlotType.

StreamPlot is the plot type associated with plotting function streamplot. Check the docstring for streamplot for further information.

source


# Makie.TextboxType.

Makie.Textbox <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.TimeSeriesType.

TimeSeries is the plot type associated with plotting function timeseries. Check the docstring for timeseries for further information.

source


# Makie.ToggleType.

Makie.Toggle <: Block

No docstring defined.

Attributes

(type ?Makie.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

source


# Makie.TooltipType.

Tooltip is the plot type associated with plotting function tooltip. Check the docstring for tooltip for further information.

source


# Makie.TransformationType.

Holds the transformations for Scenes.

Fields

  • parent::Base.RefValue{Transformation}

  • translation::Observable{Vec{3, Float64}}

  • scale::Observable{Vec{3, Float64}}

  • rotation::Observable{Quaternionf}

  • model::Observable{StaticArraysCore.SMatrix{4, 4, Float64, 16}}

  • parent_model::Observable{StaticArraysCore.SMatrix{4, 4, Float64, 16}}

  • transform_func::Observable{Any}

source


# Makie.TricontourfType.

Tricontourf is the plot type associated with plotting function tricontourf. Check the docstring for tricontourf for further information.

source


# Makie.TriplotType.

Triplot is the plot type associated with plotting function triplot. Check the docstring for triplot for further information.

source


# Makie.VLinesType.

VLines is the plot type associated with plotting function vlines. Check the docstring for vlines for further information.

source


# Makie.VSpanType.

VSpan is the plot type associated with plotting function vspan. Check the docstring for vspan for further information.

source


# Makie.VideoStreamMethod.
julia
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 or html output. Defaults to 0, which

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

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

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.

source


# Makie.ViolinType.

Violin is the plot type associated with plotting function violin. Check the docstring for violin for further information.

source


# Makie.VolumeSlicesType.

VolumeSlices is the plot type associated with plotting function volumeslices. Check the docstring for volumeslices for further information.

source


# Makie.VoronoiplotType.

Voronoiplot is the plot type associated with plotting function voronoiplot. Check the docstring for voronoiplot for further information.

source


# Makie.WaterfallType.

Waterfall is the plot type associated with plotting function waterfall. Check the docstring for waterfall for further information.

source


# Makie.WilkinsonTicksMethod.
julia
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:

optimize_ticks(xmin, xmax; extend_ticks::Bool = false, Q = [(1.0,1.0), (5.0, 0.9), (2.0, 0.7), (2.5, 0.5), (3.0, 0.2)], k_min = 2, k_max = 10, k_ideal = 5, granularity_weight = 1/4, simplicity_weight = 1/6, coverage_weight = 1/3, niceness_weight = 1/4, strict_span = 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 [x_min, x_max]. 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 qQ.

  • v: 1 if label range includes 0, 0 otherwise.

source


# FileIO.saveMethod.
julia
FileIO.save(filename, scene; size = size(scene), pt_per_unit = 0.75, px_per_unit = 1.0)

Save a Scene with the specified filename and format.

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.

source


# FileIO.saveMethod.
julia
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.

source


# Makie.PatternMethod.
julia
Pattern(image)
Pattern(mask[; color1, color2])

Creates an ImagePattern from an image (a matrix of colors) or a mask (a matrix of real numbers). The pattern can be passed as a color to a plot to texture it. If a mask is passed, one can specify to colors between which colors are interpolated.

source


# Makie.PatternMethod.
julia
Pattern(style::String = "/"; kwargs...)
Pattern(style::Char = '/'; kwargs...)

Creates a line pattern based on the given argument. Available patterns are '/', '\', '-', '|', 'x', and '+'. All keyword arguments correspond to the keyword arguments for LinePattern.

source


# Makie.RecordMethod.
julia
Record(func, figlike, [iter]; kw_args...)

Check Makie.record for documentation.

source


# Makie.ablinesFunction.
julia
ablines(intercepts, slopes; attrs...)

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

Plot type

The plot type alias for the ablines function is ABLines.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.ablines!Function.

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

source


# Makie.activate_interaction!Method.
julia
activate_interaction!(parent, name::Symbol)

Activate the interaction named name registered in parent.

source


# Makie.addmouseevents!Method.
julia
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

source


# Makie.annotationsFunction.
julia
annotations(strings::Vector{String}, positions::Vector{Point})

Plots an array of texts at each position in positions.

Plot type

The plot type alias for the annotations function is Annotations.

Attributes

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

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

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

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

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

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

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

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

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

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

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

glowcolor = (:black, 0.0) — Sets the color of the glow effect around the text.

glowwidth = 0.0 — Sets the size of a glow effect around the text.

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

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

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

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

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

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

lineheight = 1.0 — The lineheight multiplier.

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

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

rotation = 0.0 — Rotates text around the given position

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

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

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

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

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

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

transformation = automaticNo docs available.

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

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

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

source


# Makie.annotations!Function.

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

source


# Makie.arcFunction.
julia
arc(origin, radius, start_angle, stop_angle; kwargs...)

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

Examples:

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

Plot type

The plot type alias for the arc function is Arc.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

joinstyle = @inherit joinstyle — Controls the rendering at corners. Options are :miter for sharp corners, :bevel for "cut off" corners, and :round for rounded corners. If the corner angle is below miter_limit, :miter is equivalent to :bevel to avoid long spikes.

linecap = @inherit linecap — Sets the type of line cap used. Options are :butt (flat without extrusion), :square (flat with half a linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

miter_limit = @inherit miter_limit — Sets the minimum inner join angle below which miter joins truncate. See also Makie.miter_distance_to_angle.

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

nan_color = :transparent — The color for NaN values.

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

resolution = 361 — The number of line points approximating the arc.

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.arc!Function.

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

source


# Makie.autolimits!Function.
julia
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.

source


# Makie.autolimits!Method.
julia
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().

source


# Makie.available_gradientsMethod.
julia
available_gradients()

Prints all available gradient names.

source


# Makie.available_marker_symbolsMethod.
julia
available_marker_symbols()

Displays all available marker symbols.

source


# Makie.available_plotting_methodsMethod.
julia
available_plotting_methods()

Returns an array of all available plotting functions.

source


# Makie.axis3dMethod.
julia
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)

source


# Makie.axislegendMethod.
julia
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.

source


# Makie.bandFunction.
julia
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.

Plot type

The plot type alias for the band function is Band.

Attributes

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

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

color = @inherit 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.

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

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

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

cycle = [:color => :patchcolor]No docs available.

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

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

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

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

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

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

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

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

interpolate = true — sets whether colors should be interpolated

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

matcap = nothingNo docs available.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

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

nan_color = :transparent — The color for NaN values.

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

shading = NoShading — 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.

shininess = 32.0 — Sets how sharp the reflection is.

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

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

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

transformation = automaticNo docs available.

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

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

source


# Makie.band!Function.

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

source


# Makie.barplotFunction.
julia
barplot(positions, heights; kwargs...)

Plots a barplot.

Plot type

The plot type alias for the barplot function is BarPlot.

Attributes

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

bar_labels = nothing — Labels added at the end of each bar.

color = @inherit patchcolorNo docs available.

color_over_background = automaticNo docs available.

color_over_bar = automaticNo docs available.

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

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

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

cycle = [:color => :patchcolor]No docs available.

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

direction = :y — Controls the direction of the bars, can be :y (vertical) or :x (horizontal).

dodge = automaticNo docs available.

dodge_gap = 0.03No docs available.

fillto = automatic — Controls the baseline of the bars. This is zero in the default automatic case unless the barplot is in a log-scaled Axis. With a log scale, the automatic default is half the minimum value because zero is an invalid value for a log scale.

flip_labels_at = InfNo docs available.

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

gap = 0.2 — The final width of the bars is calculated as w * (1 - gap) where w is the width of each bar as determined with the width attribute.

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

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

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

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

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

label_align = automaticNo docs available.

label_color = @inherit textcolorNo docs available.

label_font = @inherit font — The font of the bar labels.

label_formatter = bar_label_formatterNo docs available.

label_offset = 5 — The distance of the labels from the bar ends in screen units.

label_rotation = No docs available.

label_size = @inherit fontsize — The font size of the bar labels.

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

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

n_dodge = automaticNo docs available.

nan_color = :transparent — The color for NaN values.

offset = 0.0No docs available.

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

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

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

stack = automaticNo docs available.

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

transformation = automaticNo docs available.

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

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

width = automatic — The gapless width of the bars. If automatic, the width w is calculated as minimum(diff(sort(unique(positions))). The actual width of the bars is calculated as w * (1 - gap).

source


# Makie.barplot!Function.

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

source


# Makie.boundingboxFunction.
julia
boundingbox(plot::AbstractPlot)

Returns the world space bounding box of a plot. This include plot.transformation, i.e. the transform_func and the model matrix.

See also: data_limits

source


# Makie.boundingboxFunction.
julia
boundingbox(scenelike[, exclude = plot -> false])

Returns the combined world space bounding box of all plots collected under scenelike. This include plot.transformation, i.e. the transform_func and the model matrix. Plots with exclude(plot) == true are excluded.

See also: data_limits

source


# Makie.boxplotFunction.
julia
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

Plot type

The plot type alias for the boxplot function is BoxPlot.

Attributes

color = @inherit patchcolorNo docs available.

colormap = @inherit colormapNo docs available.

colorrange = automaticNo docs available.

colorscale = identityNo docs available.

cycle = [:color => :patchcolor]No docs available.

dodge = automatic — 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.

gap = 0.2 — Shrinking factor, width -> width * (1 - gap).

inspectable = @inherit inspectableNo docs available.

marker = @inherit markerNo docs available.

markersize = @inherit markersizeNo docs available.

mediancolor = @inherit linecolorNo docs available.

medianlinewidth = @inherit linewidthNo docs available.

n_dodge = automaticNo docs available.

notchwidth = 0.5 — Multiplier of width for narrowest width of notch.

orientation = :vertical — Orientation of box (:vertical or :horizontal).

outliercolor = automaticNo docs available.

outlierstrokecolor = @inherit markerstrokecolorNo docs available.

outlierstrokewidth = @inherit markerstrokewidthNo docs available.

range = 1.5 — Multiple of IQR controlling whisker length.

show_median = true — Show median as midline.

show_notch = false — Draw the notch.

show_outliers = true — Show outliers as points.

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

weights = automatic — Vector of statistical weights (length of data). By default, each observation has weight 1.

whiskercolor = @inherit linecolorNo docs available.

whiskerlinewidth = @inherit linewidthNo docs available.

whiskerwidth = 0.0 — Multiplier of width for width of T's on whiskers, or :match to match width.

width = automatic — Width of the box before shrinking.

source


# Makie.boxplot!Function.

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

source


# Makie.bracketFunction.
julia
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.

Plot type

The plot type alias for the bracket function is Bracket.

Attributes

align = (:center, :center)No docs available.

color = @inherit linecolorNo docs available.

font = @inherit fontNo docs available.

fontsize = @inherit fontsizeNo docs available.

joinstyle = @inherit joinstyleNo docs available.

justification = automaticNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = :solidNo docs available.

linewidth = @inherit linewidthNo docs available.

miter_limit = @inherit miter_limitNo docs available.

offset = 0 — The offset of the bracket perpendicular to the line from start to end point in screen units. The direction depends on the orientation attribute.

orientation = :up — Which way the bracket extends relative to the line from start to end point. Can be :up or :down.

rotation = automaticNo docs available.

style = :curlyNo docs available.

text = ""No docs available.

textcolor = @inherit textcolorNo docs available.

textoffset = automaticNo docs available.

width = 15 — The width of the bracket (perpendicularly away from the line from start to end point) in screen units.

source


# Makie.bracket!Function.

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

source


# Makie.broadcast_foreachMethod.
julia
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.

source


# Makie.cam2d!Method.
julia
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.

source


# Makie.cam2dMethod.

Creates a subscene with a pixel camera

source


# Makie.cam3d!Method.
julia
cam3d!(scene[; kwargs...])

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

source


# Makie.cam3d_cad!Method.
julia
cam3d_cad!(scene[; kwargs...])

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

source


# Makie.cam_relative!Method.
julia
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.

source


# Makie.campixel!Method.
julia
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.

source


# Makie.categorical_colorsMethod.
julia
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.

source


# Makie.colorbufferFunction.
julia
colorbuffer(scene, format::ImageStorageFormat = JuliaNative; update=true, backend=current_backend(), screen_config...)

Returns the content of the given scene or screen rasterised to a Matrix of Colors. The return type is backend-dependent, but will be some form of RGB or RGBA.

  • backend::Module: A module which is a Makie backend. For example, backend = GLMakie, backend = CairoMakie, etc.

  • format = JuliaNative : Returns a buffer in the format of standard julia images (dims permuted and one reversed)

  • format = GLNative : Returns a more efficient format buffer for GLMakie which can be directly used in FFMPEG without conversion

  • screen_config: Backend dependent, look up via ?Backend.Screen/Base.doc(Backend.Screen)

  • update=true: resets/updates limits. Set to false, if you want to preserver camera movements.

source


# Makie.colorbufferMethod.
julia
colorbuffer(ax::Axis; include_decorations=true, colorbuffer_kws...)

Gets the colorbuffer of the Axis in JuliaNative image format. If include_decorations=false, only the inside of the axis is fetched.

source


# Makie.contourFunction.
julia
contour(x, y, z)
contour(z::Matrix)

Creates a contour plot of the plane spanning x::Vector, y::Vector, z::Matrix. If only z::Matrix is supplied, the indices of the elements in z will be used as the x and y locations when plotting the contour.

Plot type

The plot type alias for the contour function is Contour.

Attributes

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

color = nothing — The color of the contour lines. If nothing, the color is determined by the numerical values of the contour levels in combination with colormap and colorrange.

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

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

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

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

enable_depth = trueNo docs available.

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

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

labelcolor = nothing — Color of the contour labels, if nothing it matches color by default.

labelfont = @inherit font — The font of the contour labels.

labelformatter = contour_label_formatter — Formats the numeric values of the contour levels to strings.

labels = false — If true, adds text labels to the contour lines.

labelsize = 10 — Font size of the contour labels

levels = 5 — Controls the number and location of the contour lines. 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

linecap = @inherit linecapNo docs available.

linestyle = nothingNo docs available.

linewidth = 1.0No docs available.

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

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.contour!Function.

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

source


# Makie.contour3dFunction.
julia
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.

Plot type

The plot type alias for the contour3d function is Contour3d.

Attributes

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

color = nothing — The color of the contour lines. If nothing, the color is determined by the numerical values of the contour levels in combination with colormap and colorrange.

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

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

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

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

enable_depth = trueNo docs available.

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

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

labelcolor = nothing — Color of the contour labels, if nothing it matches color by default.

labelfont = @inherit font — The font of the contour labels.

labelformatter = contour_label_formatter — Formats the numeric values of the contour levels to strings.

labels = false — If true, adds text labels to the contour lines.

labelsize = 10 — Font size of the contour labels

levels = 5 — Controls the number and location of the contour lines. 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

linecap = @inherit linecapNo docs available.

linestyle = nothingNo docs available.

linewidth = 1.0No docs available.

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

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.contour3d!Function.

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

source


# Makie.contourfFunction.
julia
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.

Plot type

The plot type alias for the contourf function is Contourf.

Attributes

colormap = @inherit colormapNo docs available.

colorscale = identityNo docs available.

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

extendhigh = nothing — In :normal mode, if you want to show a band from the high edge to Inf, set extendhigh to :auto to give the extension the same color as the last level, or specify a color directly (default nothing means no extended band).

extendlow = nothing — In :normal mode, if you want to show a band from -Inf to the low edge, set extendlow to :auto to give the extension the same color as the first level, or specify a color directly (default nothing means no extended band).

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

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

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

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

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

levels = 10 — 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

If levels is an Int, the contourf plot will be rectangular as all zs values will be covered edge to edge. 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.

mode = :normal — Determines how the levels attribute is interpreted, either :normal or :relative. In :normal mode, the levels correspond directly to the z values. In :relative 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.

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

nan_color = :transparentNo docs available.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.contourf!Function.

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

source


# Makie.crossbarFunction.
julia
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

Plot type

The plot type alias for the crossbar function is CrossBar.

Attributes

color = @inherit patchcolorNo docs available.

colormap = @inherit colormapNo docs available.

colorrange = automaticNo docs available.

colorscale = identityNo docs available.

cycle = [:color => :patchcolor]No docs available.

dodge = automaticNo docs available.

dodge_gap = 0.03No docs available.

gap = 0.2 — Shrinking factor, width -> width * (1 - gap).

inspectable = @inherit inspectableNo docs available.

midlinecolor = automaticNo docs available.

midlinewidth = @inherit linewidthNo docs available.

n_dodge = automaticNo docs available.

notchmax = automatic — Upper limit of the notch.

notchmin = automatic — Lower limit of the notch.

notchwidth = 0.5 — Multiplier of width for narrowest width of notch.

orientation = :vertical — Orientation of box (:vertical or :horizontal).

show_midline = true — Show midline.

show_notch = false — Whether to draw the notch.

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

width = automatic — Width of the box before shrinking.

source


# Makie.crossbar!Function.

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

source


# Makie.current_axis!Method.
julia
current_axis!(ax)

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

source


# Makie.current_axis!Method.
julia
current_axis!(fig::Figure, ax)

Set ax as the current active axis in fig.

source


# Makie.current_axisMethod.
julia
current_axis()

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

source


# Makie.current_figure!Method.
julia
current_figure!(fig)

Set fig as the current active figure.

source


# Makie.current_figureMethod.
julia
current_figure()

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

source


# Makie.data_limitsFunction.
julia
data_limits(scenelike[, exclude = plot -> false])

Returns the combined data limits of all plots collected under scenelike for which exclude(plot) == false. This is solely based on the positional data of a plot and thus does not include any transformations.

See also: boundingbox

source


# Makie.data_limitsMethod.
julia
data_limits(plot::AbstractPlot)

Returns the bounding box of a plot based on just its position data.

See also: boundingbox

source


# Makie.datashaderFunction.
julia
datashader(points::AbstractVector{<: Point})

Warning

This feature might change outside breaking releases, since the API is not yet finalized. Please be wary 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:

Julia
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 than just copying the data 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.

Plot type

The plot type alias for the datashader function is DataShader.

Attributes

agg = AggCount() — Can be AggCount(), AggAny() or AggMean(). User-extensible 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

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

async = 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.

binsize = 1 — Factor defining how many bins one wants per screen pixel. Set to n > 1 if you want a coarser image.

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

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

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

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

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

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

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

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

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

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

interpolate = true — If the resulting image should be displayed interpolated.

local_operation = identity — Function which gets called on each element after the aggregation (map!(x-> local_operation(x), final_aggregation_result)).

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

method = AggThreads() — Can be AggThreads() or AggSerial() for threaded vs. serial aggregation.

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

nan_color = :transparent — The color for NaN values.

operation = automatic — Defaults to Makie.equalize_histogram function which gets called on the whole get_aggregation array before display (operation(final_aggregation_result)).

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

point_transform = identity — Function which gets applied to every point before aggregating it.

show_timings = false — Set to true to show how long it takes to aggregate each frame.

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.datashader!Function.

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

source


# Makie.deactivate_interaction!Method.
julia
deactivate_interaction!(parent, name::Symbol)

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

source


# Makie.densityFunction.
julia
density(values)

Plot a kernel density estimate of values.

Plot type

The plot type alias for the density function is Density.

Attributes

bandwidth = automatic — Kernel density bandwidth, determined automatically if automatic.

boundary = automatic — Boundary of the density estimation, determined automatically if automatic.

color = @inherit patchcolor — 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.

colormap = @inherit colormapNo docs available.

colorrange = Makie.automaticNo docs available.

colorscale = identityNo docs available.

cycle = [:color => :patchcolor]No docs available.

direction = :x — The dimension along which the values are distributed. Can be :x or :y.

inspectable = @inherit inspectableNo docs available.

linestyle = nothingNo docs available.

npoints = 200 — The resolution of the estimated curve along the dimension set in direction.

offset = 0.0 — Shift the density baseline, for layering multiple densities on top of each other.

strokearound = falseNo docs available.

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

weights = automatic — Assign a vector of statistical weights to values.

source


# Makie.density!Function.

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

source


# Makie.deregister_interaction!Method.
julia
deregister_interaction!(parent, name::Symbol)

Deregister the interaction named name registered in parent.

source


# Makie.ecdfplotFunction.
julia
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.

Plot type

The plot type alias for the ecdfplot function is ECDFPlot.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

joinstyle = @inherit joinstyle — Controls the rendering at corners. Options are :miter for sharp corners, :bevel for "cut off" corners, and :round for rounded corners. If the corner angle is below miter_limit, :miter is equivalent to :bevel to avoid long spikes.

linecap = @inherit linecap — Sets the type of line cap used. Options are :butt (flat without extrusion), :square (flat with half a linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

miter_limit = @inherit miter_limit — Sets the minimum inner join angle below which miter joins truncate. See also Makie.miter_distance_to_angle.

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

nan_color = :transparent — The color for NaN values.

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

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

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

step = :pre — 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.

transformation = automaticNo docs available.

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

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

source


# Makie.ecdfplot!Function.

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

source


# Makie.errorbarsFunction.
julia
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.

Plot type

The plot type alias for the errorbars function is Errorbars.

Attributes

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

color = @inherit linecolor — The color of the lines. Can be an array to color each bar separately.

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

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

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

cycle = [:color]No docs available.

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

direction = :y — The direction in which the bars are drawn. Can be :x or :y.

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

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

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

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

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

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

linecap = @inherit linecapNo docs available.

linewidth = @inherit linewidth — The thickness of the lines in screen units.

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

whiskerwidth = 0 — The width of the whiskers or line caps in screen units.

source


# Makie.errorbars!Function.

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

source


# Makie.fill_between!Method.
julia
fill_between!(scenelike, x, y1, y2; where = nothing, kw_args...)

fill the section between 2 lines with the condition where

source


# Makie.helpMethod.
julia
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.

source


# Makie.help_argumentsMethod.
julia
help_arguments([io], func)

Returns a list of signatures for function func.

source


# Makie.help_attributesMethod.
julia
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:

julia
>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

source


# Makie.hexbinFunction.
julia
hexbin(xs, ys; kwargs...)

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

Plot type

The plot type alias for the hexbin function is Hexbin.

Attributes

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

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.

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

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

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

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

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

nan_color = :transparent — The color for NaN values.

strokecolor = :blackNo docs available.

strokewidth = 0No docs available.

threshold = 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.

weights = nothing — Weights for each observation. Can be nothing (each observation carries weight 1) or any AbstractVector{<: Real} or StatsBase.AbstractWeights.

source


# Makie.hexbin!Function.

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

source


# Makie.hidedecorations!Method.
julia
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!]

source


# Makie.hidedecorations!Method.
julia
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!]

source


# Makie.hiderdecorations!Method.
julia
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.

source


# Makie.hidespines!Method.
julia
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).

source


# Makie.hidethetadecorations!Method.
julia
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.

source


# Makie.hidexdecorations!Method.
julia
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.

source


# Makie.hideydecorations!Method.
julia
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.

source


# Makie.hidezdecorations!Method.
julia
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.

source


# Makie.histFunction.
julia
hist(values)

Plot a histogram of values.

Plot type

The plot type alias for the hist function is Hist.

Attributes

bar_labels = nothingNo docs available.

bins = 15 — 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.

color = @inherit patchcolor — Color can either be:

  • a vector of bins colors

  • a single color

  • :values, to color the bars with the values from the histogram

cycle = [:color => :patchcolor]No docs available.

direction = :y — Set the direction of the bars.

fillto = automatic — Defines where the bars start.

flip_labels_at = InfNo docs available.

gap = 0 — Gap between the bars (see barplot).

label_color = @inherit textcolorNo docs available.

label_font = @inherit fontNo docs available.

label_formatter = bar_label_formatterNo docs available.

label_offset = 5No docs available.

label_size = 20No docs available.

normalization = :none — Allows to normalize the histogram. 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.

offset = 0.0 — Adds an offset to every value.

over_background_color = automaticNo docs available.

over_bar_color = automaticNo docs available.

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.

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

weights = automatic — Allows to statistically weight the observations.

source


# Makie.hist!Function.

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

source


# Makie.hlinesFunction.
julia
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.

Plot type

The plot type alias for the hlines function is HLines.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

xmax = 1 — The end of the lines in relative axis units (0 to 1) along the x dimension.

xmin = 0 — The start of the lines in relative axis units (0 to 1) along the x dimension.

source


# Makie.hlines!Function.

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

source


# Makie.hovered_sceneMethod.
julia
hovered_scene()

Returns the scene that the mouse is currently hovering over.

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

source


# Makie.hspanFunction.
julia
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.

Plot type

The plot type alias for the hspan function is HSpan.

Attributes

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

color = @inherit 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.

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

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

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

cycle = [:color => :patchcolor]No docs available.

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

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

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

shading = NoShadingNo docs available.

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

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

strokecolor = @inherit patchstrokecolor — Sets the color of the outline around a marker.

strokecolormap = @inherit colormap — Sets the colormap that is sampled for numeric colors.

strokewidth = @inherit patchstrokewidth — Sets the width of the outline.

transformation = automaticNo docs available.

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

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

xmax = 1 — The end of the bands in relative axis units (0 to 1) along the x dimension.

xmin = 0 — The start of the bands in relative axis units (0 to 1) along the x dimension.

source


# Makie.hspan!Function.

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

source


# Makie.is_mouseinsideMethod.
julia
is_mouseinside(scene)

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

source


# Makie.ispressedFunction.

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.

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

source


# Makie.labelslider!Method.
julia
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

source


# Makie.labelslidergrid!Method.
julia
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

source


# Makie.limits!Method.
julia
limits!(ax::Axis, xlims, ylims)

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

source


# Makie.limits!Method.
julia
limits!(ax::Axis, rect::Rect2)

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

source


# Makie.limits!Method.
julia
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.

source


# Makie.limits!Method.
julia
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.

source


# Makie.limits!Method.
julia
limits!(ax::Axis3, rect::Rect3)

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

source


# Makie.limits!Method.
julia
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.

source


# Makie.linkaxes!Method.
julia
linkaxes!(a::Axis, others...)

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

source


# Makie.linkxaxes!Method.
julia
linkxaxes!(a::Axis, others...)

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

source


# Makie.linkyaxes!Method.
julia
linkyaxes!(a::Axis, others...)

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

source


# Makie.mouseoverMethod.
julia
mouseover(fig/ax/scene, plots::AbstractPlot...)

Returns true if the mouse currently hovers any of plots.

source


# Makie.mousepositionMethod.
julia
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.

source


# Makie.old_cam3d!Method.
julia
old_cam3d!(scene; kwargs...)

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

source


# Makie.old_cam3d_cad!Method.
julia
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.

source


# Makie.old_cam3d_turntable!Method.
julia
old_cam3d_turntable!(scene; kw_args...)

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

source


# Makie.onmousedownoutsideMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === downoutside.

source


# Makie.onmouseenterMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === enter.

source


# Makie.onmouseleftclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftclick.

source


# Makie.onmouseleftdoubleclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftdoubleclick.

source


# Makie.onmouseleftdownMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftdown.

source


# Makie.onmouseleftdragMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftdrag.

source


# Makie.onmouseleftdragstartMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftdragstart.

source


# Makie.onmouseleftdragstopMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftdragstop.

source


# Makie.onmouseleftupMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === leftup.

source


# Makie.onmousemiddleclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middleclick.

source


# Makie.onmousemiddledoubleclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middledoubleclick.

source


# Makie.onmousemiddledownMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middledown.

source


# Makie.onmousemiddledragMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middledrag.

source


# Makie.onmousemiddledragstartMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middledragstart.

source


# Makie.onmousemiddledragstopMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middledragstop.

source


# Makie.onmousemiddleupMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === middleup.

source


# Makie.onmouseoutMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === out.

source


# Makie.onmouseoverMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === over.

source


# Makie.onmouserightclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightclick.

source


# Makie.onmouserightdoubleclickMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightdoubleclick.

source


# Makie.onmouserightdownMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightdown.

source


# Makie.onmouserightdragMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightdrag.

source


# Makie.onmouserightdragstartMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightdragstart.

source


# Makie.onmouserightdragstopMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightdragstop.

source


# Makie.onmouserightupMethod.

Executes the function f whenever the MouseEventHandle's observable is set to a MouseEvent with event.type === rightup.

source


# Makie.onpickFunction.
julia
onpick(func, plot)

Calls func if one clicks on plot. Implemented by the backend.

source


# Makie.onpickMethod.
julia
onpick(f, fig/ax/scene, plots::AbstractPlot...)

Calls f(plot, idx) whenever the mouse is over any of plots. idx is an index, e.g. when over a scatter plot, it will be the index of the hovered element

source


# Makie.pickFunction.

Picks a mouse position. Implemented by the backend.

source


# Makie.pickMethod.
julia
pick(scene::Scene, rect::Rect2i)

Return all (plot, index) pairs within the given rect. The rect must be within screen boundaries.

source


# Makie.pickMethod.
julia
pick(fig/ax/scene, x, y)

Returns the plot under pixel position (x, y).

source


# Makie.pickMethod.
julia
pick(fig/ax/scene, xy::VecLike, range)

Return the plot closest to xy within a given range.

source


# Makie.pickMethod.
julia
pick(fig/ax/scene, xy::VecLike)

Return the plot under pixel position xy.

source


# Makie.pieFunction.
julia
pie(values; kwargs...)

Creates a pie chart from the given values.

Plot type

The plot type alias for the pie function is Pie.

Attributes

color = :grayNo docs available.

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

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

inner_radius = 0 — The inner radius of the pie segments. If this is larger than zero, the pie pieces become ring sections.

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

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

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

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

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

normalize = true — If true, the sum of all values is normalized to 2π (a full circle).

offset = 0 — The angular offset of the first pie segment from the (1, 0) vector in radians.

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

radius = 1 — The outer radius of the pie segments.

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

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

strokecolor = :blackNo docs available.

strokewidth = 1No docs available.

transformation = automaticNo docs available.

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

vertex_per_deg = 1 — Controls how many polygon vertices are used for one degree of rotation.

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

source


# Makie.pie!Function.

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

source


# Makie.plotlistMethod.
julia
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

julia
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)),
]

source


# Makie.qqnormFunction.
julia
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.

Plot type

The plot type alias for the qqnorm function is QQNorm.

Attributes

color = @inherit linecolor — Control color of both line and markers (if markercolor is not specified).

cycle = [:color]No docs available.

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

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

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

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

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

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

linestyle = nothingNo docs available.

linewidth = @inherit linewidthNo docs available.

marker = @inherit markerNo docs available.

markercolor = automaticNo docs available.

markersize = @inherit markersizeNo docs available.

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

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

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

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

strokecolor = @inherit markerstrokecolorNo docs available.

strokewidth = @inherit markerstrokewidthNo docs available.

transformation = automaticNo docs available.

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

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

source


# Makie.qqnorm!Function.

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

source


# Makie.qqplotFunction.
julia
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.

Plot type

The plot type alias for the qqplot function is QQPlot.

Attributes

color = @inherit linecolor — Control color of both line and markers (if markercolor is not specified).

cycle = [:color]No docs available.

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

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

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

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

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

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

linestyle = nothingNo docs available.

linewidth = @inherit linewidthNo docs available.

marker = @inherit markerNo docs available.

markercolor = automaticNo docs available.

markersize = @inherit markersizeNo docs available.

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

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

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

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

strokecolor = @inherit markerstrokecolorNo docs available.

strokewidth = @inherit markerstrokewidthNo docs available.

transformation = automaticNo docs available.

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

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

source


# Makie.qqplot!Function.

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

source


# Makie.raincloudsFunction.
julia
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

Violin/Histogram Plot Specific Keywords

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.

Plot type

The plot type alias for the rainclouds function is RainClouds.

Attributes

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.

boxplot_width = 0.1 — Width of the boxplot on the category axis.

center_boxplot = true — Whether or not to center the boxplot on the category.

cloud_width = 0.75 — Determines size of violin plot. Corresponds to width keyword arg in violin.

clouds = violin — [violin, hist, nothing] how to show cloud plots, either as violin or histogram plots, or not at all.

color = @inherit patchcolor — A single color, or a vector of colors, one for each point.

cycle = [:color => :patchcolor]No docs available.

dodge = automatic — Vector of Integer (length of data) of grouping variable to create multiple side-by-side boxes at the same x position

dodge_gap = 0.01 — Spacing between dodged boxes.

gap = 0.2 — Distance between elements on the main axis (depending on orientation).

hist_bins = 30 — If clouds=hist, this passes down the number of bins to the histogram call.

markersize = 2.0 — Size of marker used for the scatter plot.

n_dodge = automatic — The number of categories to dodge (defaults to maximum(dodge))

orientation = :vertical — Orientation of rainclouds (:vertical or :horizontal)

plot_boxplots = true — Whether to show boxplots to summarize distribution of data.

show_boxplot_outliers = false — Show outliers in the boxplot as points (usually confusing when paired with the scatter plot so the default is to not show them)

show_median = true — Determines whether or not to have a line for the median value in the boxplot.

side = :left — Can take values of :left, :right, determines where the violin plot will be, relative to the scatter points

strokewidth = 1.0 — Determines the stroke width for the outline of the boxplot.

violin_limits = (-Inf, Inf) — Specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema)

whiskerwidth = 0.5 — The width of the Q1, Q3 whisker in the boxplot. Value as a portion of the boxplot_width.

source


# Makie.rainclouds!Function.

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

source


# Makie.rangebarsFunction.
julia
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.

Plot type

The plot type alias for the rangebars function is Rangebars.

Attributes

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

color = @inherit linecolor — The color of the lines. Can be an array to color each bar separately.

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

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

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

cycle = [:color]No docs available.

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

direction = :y — The direction in which the bars are drawn. Can be :x or :y.

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

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

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

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

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

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

linecap = @inherit linecapNo docs available.

linewidth = @inherit linewidth — The thickness of the lines in screen units.

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

whiskerwidth = 0 — The width of the whiskers or line caps in screen units.

source


# Makie.rangebars!Function.

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

source


# Makie.recordMethod.
julia
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 or html output. Defaults to 0, which

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

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

Typical usage

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

or, for more tweakability,

julia
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

julia
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

or

julia
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

source


# Makie.record_eventsMethod.

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

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

source


# Makie.recordframe!Method.
julia
recordframe!(io::VideoStream)

Adds a video frame to the VideoStream io.

source


# Makie.register_interaction!Method.
julia
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!.

source


# Makie.register_interaction!Method.
julia
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!.

source


# Makie.replace_automatic!Method.

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

source


# Makie.replay_eventsMethod.

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

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

source


# Makie.resample_cmapMethod.
julia
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.

source


# Makie.reset_limits!Method.
julia
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.

source


# Makie.resize_to_layout!Method.
julia
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.

source


# Makie.rlims!Method.
julia
rlims!(ax::PolarAxis[, rmin], rmax)

Sets the radial limits of a given PolarAxis.

source


# Makie.rotate!Method.
julia
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.

source


# Makie.rotate!Method.
julia
rotate!(Accum, t::Transformable, axis_rot...)

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

source


# Makie.rotate_cam!Function.
julia
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.

source


# Makie.rotate_cam!Method.
julia
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 (α, β, γ).

source


# Makie.scale!Method.
julia
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.

source


# Makie.scatterlinesFunction.
julia
scatterlines(xs, ys, [zs]; kwargs...)

Plots scatter markers and lines between them.

Plot type

The plot type alias for the scatterlines function is ScatterLines.

Attributes

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

color = @inherit linecolor — The color of the line, and by default also of the scatter markers.

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

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

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

cycle = [:color]No docs available.

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

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

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

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

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

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

marker = @inherit marker — Sets the scatter marker.

markercolor = automaticNo docs available.

markercolormap = automaticNo docs available.

markercolorrange = automaticNo docs available.

markersize = @inherit markersize — Sets the size of the marker.

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

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

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

strokecolor = @inherit markerstrokecolor — Sets the color of the outline around a marker.

strokewidth = @inherit markerstrokewidth — Sets the width of the outline around a marker.

transformation = automaticNo docs available.

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

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

source


# Makie.scatterlines!Function.

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

source


# Makie.select_lineMethod.
julia
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.

source


# Makie.select_pointMethod.
julia
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.

source


# Makie.select_rectangleMethod.
julia
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 observable rect 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.

source


# Makie.seriesFunction.
julia
series(curves)

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

If any of marker, markersize, markercolor, strokecolor or strokewidth is set != nothing, a scatterplot is added.

Plot type

The plot type alias for the series function is Series.

Attributes

color = :lighttestNo docs available.

joinstyle = @inherit joinstyleNo docs available.

labels = nothingNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = :solidNo docs available.

linewidth = 2No docs available.

marker = nothingNo docs available.

markercolor = automaticNo docs available.

markersize = nothingNo docs available.

miter_limit = @inherit miter_limitNo docs available.

solid_color = nothingNo docs available.

space = :dataNo docs available.

strokecolor = nothingNo docs available.

strokewidth = nothingNo docs available.

source


# Makie.series!Function.

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

source


# Makie.set_close_to!Method.

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.

source


# Makie.set_close_to!Method.
julia
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.

source


# Makie.set_theme!Function.
julia
set_theme(theme; kwargs...)

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

source


# Makie.showgradientsMethod.
julia
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.

source


# Makie.spyFunction.

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

Visualizes big sparse matrices. Usage:

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

Plot type

The plot type alias for the spy function is Spy.

Attributes

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

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

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

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

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

framecolor = :blackNo docs available.

framesize = 1No docs available.

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

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

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

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

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

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

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

marker = automaticNo docs available.

markersize = automaticNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.spy!Function.

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

source


# Makie.stairsFunction.
julia
stairs(xs, ys; kwargs...)

Plot a stair function.

The conversion trait of stairs is PointBased.

Plot type

The plot type alias for the stairs function is Stairs.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

joinstyle = @inherit joinstyle — Controls the rendering at corners. Options are :miter for sharp corners, :bevel for "cut off" corners, and :round for rounded corners. If the corner angle is below miter_limit, :miter is equivalent to :bevel to avoid long spikes.

linecap = @inherit linecap — Sets the type of line cap used. Options are :butt (flat without extrusion), :square (flat with half a linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

miter_limit = @inherit miter_limit — Sets the minimum inner join angle below which miter joins truncate. See also Makie.miter_distance_to_angle.

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

nan_color = :transparent — The color for NaN values.

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

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

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

step = :pre — 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.

transformation = automaticNo docs available.

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

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

source


# Makie.stairs!Function.

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

source


# Makie.stemFunction.
julia
stem(xs, ys, [zs]; kwargs...)

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

The conversion trait of stem is PointBased.

Plot type

The plot type alias for the stem function is Stem.

Attributes

color = @inherit markercolorNo docs available.

colormap = @inherit colormapNo docs available.

colorrange = automaticNo docs available.

colorscale = identityNo docs available.

cycle = [[:stemcolor, :color, :trunkcolor] => :color]No docs available.

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

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

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

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

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

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

marker = :circleNo docs available.

markersize = @inherit markersizeNo docs available.

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

offset = 0 — 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.

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

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

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

stemcolor = @inherit linecolorNo docs available.

stemcolormap = @inherit colormapNo docs available.

stemcolorrange = automaticNo docs available.

stemlinestyle = nothingNo docs available.

stemwidth = @inherit linewidthNo docs available.

strokecolor = @inherit markerstrokecolorNo docs available.

strokewidth = @inherit markerstrokewidthNo docs available.

transformation = automaticNo docs available.

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

trunkcolor = @inherit linecolorNo docs available.

trunkcolormap = @inherit colormapNo docs available.

trunkcolorrange = automaticNo docs available.

trunklinestyle = nothingNo docs available.

trunkwidth = @inherit linewidthNo docs available.

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

source


# Makie.stem!Function.

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

source


# Makie.stephistFunction.
julia
stephist(values)

Plot a step histogram of values.

Plot type

The plot type alias for the stephist function is StepHist.

Attributes

bins = 15 — 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.

color = @inherit patchcolorNo docs available.

cycle = [:color => :patchcolor]No docs available.

linestyle = :solidNo docs available.

linewidth = @inherit linewidthNo docs available.

normalization = :none — Allows to apply a normalization to the histogram. 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.

scale_to = nothing — Allows to scale all values to a certain height.

weights = automatic — Allows to provide statistical weights.

source


# Makie.stephist!Function.

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

source


# Makie.streamplotFunction.
julia
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:

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

Implementation

See the function Makie.streamplot_impl for implementation details.

Plot type

The plot type alias for the streamplot function is StreamPlot.

Attributes

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

arrow_head = automaticNo docs available.

arrow_size = automaticNo docs available.

color = norm — One can choose the color of the lines by passing a function color_func(dx::Point) to the color attribute. This 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.

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

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

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

density = 1.0No docs available.

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

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

gridsize = (32, 32, 32)No docs available.

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = nothingNo docs available.

linewidth = @inherit linewidthNo docs available.

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

maxsteps = 500No docs available.

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

quality = 16No docs available.

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

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

stepsize = 0.01No docs available.

transformation = automaticNo docs available.

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

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

source


# Makie.streamplot!Function.

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

source


# Makie.thetalims!Method.
julia
thetalims!(ax::PolarAxis, thetamin, thetamax)

Sets the angular limits of a given PolarAxis.

source


# Makie.tight_ticklabel_spacing!Method.
julia
tight_ticklabel_spacing!(ax::Axis)

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

source


# Makie.tight_ticklabel_spacing!Method.
julia
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.

source


# Makie.tight_xticklabel_spacing!Method.
julia
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.

source


# Makie.tight_yticklabel_spacing!Method.
julia
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.

source


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

Sets the autolimit margins to zero on all given sides.

Example:

tightlimits!(laxis, Bottom())

source


# Makie.tightlimits!Method.
julia
tightlimits!(la::Axis)

Sets the autolimit margins to zero on all sides.

source


# Makie.timeseriesFunction.
julia
timeseries(x::Observable{{Union{Number, Point2}}})

Plots a sampled signal.

Usage:

julia
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

Plot type

The plot type alias for the timeseries function is TimeSeries.

Attributes

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

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

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

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

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

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

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

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

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

history = 100No docs available.

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

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

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

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

joinstyle = @inherit joinstyle — Controls the rendering at corners. Options are :miter for sharp corners, :bevel for "cut off" corners, and :round for rounded corners. If the corner angle is below miter_limit, :miter is equivalent to :bevel to avoid long spikes.

linecap = @inherit linecap — Sets the type of line cap used. Options are :butt (flat without extrusion), :square (flat with half a linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

miter_limit = @inherit miter_limit — Sets the minimum inner join angle below which miter joins truncate. See also Makie.miter_distance_to_angle.

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.timeseries!Function.

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

source


# Makie.to_alignMethod.
julia
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.

source


# Makie.to_colormapMethod.
julia
to_colormap(b::AbstractVector)

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

source


# Makie.to_colormapMethod.
julia
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.

source


# Makie.to_fontMethod.
julia
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.

source


# Makie.to_rotationMethod.
julia
rotation accepts:
to_rotation(b, quaternion)
to_rotation(b, tuple_float)
to_rotation(b, vec4)

source


# Makie.tooltipFunction.
julia
tooltip(position, string)
tooltip(x, y, string)

Creates a tooltip pointing at position displaying the given `string

Plot type

The plot type alias for the tooltip function is Tooltip.

Attributes

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.

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

font = @inherit font — Sets the font.

fontsize = 16 — Sets the text size in screen units.

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

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

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

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

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

justification = :left — Sets whether text is aligned to the :left, :center or :right within its bounding box.

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

offset = 10 — Sets the offset between the given position and the tip of the triangle pointing at that position.

outline_color = :black — Sets the color of the tooltip outline.

outline_linestyle = nothing — Sets the linestyle of the tooltip outline.

outline_linewidth = 2.0 — Sets the linewidth of the tooltip outline.

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

placement = :above — Sets where the tooltip should be placed relative to position. Can be :above, :below, :left, :right.

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

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

strokecolor = :white — Sets the text outline color.

strokewidth = 0 — Gives text an outline if set to a positive value.

text = ""No docs available.

textcolor = @inherit textcolor — Sets the text color.

textpadding = (4, 4, 4, 4) — Sets the padding around text in the tooltip. This is given as (left, right, bottom, top) offsets.

transformation = automaticNo docs available.

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

triangle_size = 10 — Sets the size of the triangle pointing at position.

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

xautolimits = falseNo docs available.

yautolimits = falseNo docs available.

zautolimits = falseNo docs available.

source


# Makie.tooltip!Function.

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

source


# Makie.translate!Method.
julia
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.

source


# Makie.translate!Method.
julia
translate!(Accum, t::Transformable, xyz...)

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

source


# Makie.translate_cam!Method.
julia
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.

source


# Makie.translate_cam!Method.
julia
translate_cam!(scene::Scene, translation::VecTypes)

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

source


# Makie.tricontourfFunction.
julia
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.

Plot type

The plot type alias for the tricontourf function is Tricontourf.

Attributes

colormap = @inherit colormap — Sets the colormap from which the band colors are sampled.

colorscale = identity — Color transform function

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

edges = nothingNo docs available.

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.

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.

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

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

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

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

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

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.

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

nan_color = :transparentNo docs available.

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

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

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

transformation = automaticNo docs available.

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

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.

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

source


# Makie.tricontourf!Function.

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

source


# Makie.triplotFunction.
julia
triplot(x, y; kwargs...)
triplot(positions; kwargs...)
triplot(triangles::Triangulation; kwargs...)

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

Plot type

The plot type alias for the triplot function is Triplot.

Attributes

bounding_box = 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 = @inherit linestyle — Sets the linestyle of the constrained edges.

constrained_edge_linewidth = @inherit linewidth — Sets the width of the constrained edges.

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 = @inherit linewidth — Sets the width of the convex hull.

ghost_edge_color = :blue — Sets the color 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.

ghost_edge_linestyle = @inherit linestyle — Sets the linestyle of the ghost edges.

ghost_edge_linewidth = @inherit linewidth — Sets the width of the ghost edges.

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = :solid — Sets the linestyle of triangle edges.

marker = @inherit marker — Sets the shape of the points.

markercolor = @inherit markercolor — Sets the color of the points.

markersize = @inherit markersize — Sets the size of the points.

miter_limit = @inherit miter_limitNo docs available.

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.

show_constrained_edges = false — Determines whether to plot the constrained edges.

show_convex_hull = false — Determines whether to plot the convex hull.

show_ghost_edges = false — Determines whether to plot the ghost edges.

show_points = false — Determines whether to plot the individual points. Note that this will only plot points included in the triangulation.

strokecolor = @inherit patchstrokecolor — Sets the color of triangle edges.

strokewidth = 1 — Sets the linewidth of triangle edges.

triangle_color = :transparent — Sets the color of the triangles.

source


# Makie.triplot!Function.

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

source


# Makie.update_cam!Function.
julia
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[].

source


# Makie.update_cam!Function.
julia
update_cam!(scene::Scene, eyeposition, lookat, up = Vec3f(0, 0, 1))

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

source


# Makie.update_cam!Method.
julia
update_cam!(scene::SceneLike, area)

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

source


# Makie.update_cam!Method.
julia
update_cam!(scene::SceneLike)

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

source


# Makie.update_theme!Function.
julia
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))

source


# Makie.viewportMethod.
julia
viewport(scene::Scene)

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

source


# Makie.violinFunction.
julia
violin(x, y)

Draw a violin plot.

Arguments

  • x: positions of the categories

  • y: variables whose density is computed

Plot type

The plot type alias for the violin function is Violin.

Attributes

bandwidth = automaticNo docs available.

boundary = automaticNo docs available.

color = @inherit patchcolorNo docs available.

cycle = [:color => :patchcolor]No docs available.

datalimits = (-Inf, Inf) — Specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema).

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

dodge = automaticNo docs available.

dodge_gap = 0.03No docs available.

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

gap = 0.2 — Shrinking factor, width -> width * (1 - gap).

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

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

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

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

max_density = automaticNo docs available.

mediancolor = @inherit linecolorNo docs available.

medianlinewidth = @inherit linewidthNo docs available.

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

n_dodge = automaticNo docs available.

npoints = 200No docs available.

orientation = :vertical — Orientation of the violins (:vertical or :horizontal)

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

scale = :area — Scale density by area (:area), count (:count), or width (:width).

show_median = false — Show median as midline.

side = :both — Specify :left or :right to only plot the violin on one side.

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

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

strokecolor = @inherit patchstrokecolorNo docs available.

strokewidth = @inherit patchstrokewidthNo docs available.

transformation = automaticNo docs available.

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

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

weights = automatic — vector of statistical weights (length of data). By default, each observation has weight 1.

width = automatic — Width of the box before shrinking.

source


# Makie.violin!Function.

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

source


# Makie.vlinesFunction.
julia
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.

Plot type

The plot type alias for the vlines function is VLines.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

ymax = 1 — The start of the lines in relative axis units (0 to 1) along the y dimension.

ymin = 0 — The start of the lines in relative axis units (0 to 1) along the y dimension.

source


# Makie.vlines!Function.

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

source


# Makie.volumeslicesFunction.

VolumeSlices

volumeslices(x, y, z, v)

Draws heatmap slices of the volume v

Plot type

The plot type alias for the volumeslices function is VolumeSlices.

Attributes

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

bbox_color = RGBAf(0.5, 0.5, 0.5, 0.5)No docs available.

bbox_visible = trueNo docs available.

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

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

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

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

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

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

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

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

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

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

interpolate = false — Sets whether colors should be interpolated

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# Makie.volumeslices!Function.

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

source


# Makie.voronoiplotFunction.
julia
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.

Plot type

The plot type alias for the voronoiplot function is Voronoiplot.

Attributes

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

clip = 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 = automatic — Sets the color of the polygons. If automatic, the polygons will be individually colored according to the colormap.

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

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

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

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

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

marker = @inherit marker — Sets the shape of the points.

markercolor = @inherit markercolor — Sets the color of the points.

markersize = @inherit markersize — Sets the size of the points.

nan_color = :transparent — The color for NaN values.

show_generators = true — Determines whether to plot the individual generators.

smooth = falseNo docs available.

strokecolor = @inherit patchstrokecolor — Sets the strokecolor of the polygons.

strokewidth = 1.0 — Sets the width of the polygon stroke.

unbounded_edge_extension_factor = 0.1 — Sets the extension factor for the unbounded edges, used in DelaunayTriangulation.polygon_bounds.

source


# Makie.voronoiplot!Function.

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

source


# Makie.vspanFunction.
julia
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.

Plot type

The plot type alias for the vspan function is VSpan.

Attributes

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

color = @inherit 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.

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

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

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

cycle = [:color => :patchcolor]No docs available.

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

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

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

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

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

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

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

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

miter_limit = @inherit miter_limitNo docs available.

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

nan_color = :transparent — The color for NaN values.

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

shading = NoShadingNo docs available.

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

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

strokecolor = @inherit patchstrokecolor — Sets the color of the outline around a marker.

strokecolormap = @inherit colormap — Sets the colormap that is sampled for numeric colors.

strokewidth = @inherit patchstrokewidth — Sets the width of the outline.

transformation = automaticNo docs available.

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

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

ymax = 1 — The end of the bands in relative axis units (0 to 1) along the y dimension.

ymin = 0 — The start of the bands in relative axis units (0 to 1) along the y dimension.

source


# Makie.vspan!Function.

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

source


# Makie.waterfallFunction.
julia
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.

Plot type

The plot type alias for the waterfall function is Waterfall.

Attributes

color = @inherit patchcolorNo docs available.

cycle = [:color => :patchcolor]No docs available.

direction_color = @inherit backgroundcolorNo docs available.

dodge = automaticNo docs available.

dodge_gap = 0.03No docs available.

final_color = plot_color(:grey90, 0.5)No docs available.

final_dodge_gap = 0No docs available.

final_gap = automaticNo docs available.

gap = 0.2No docs available.

marker_neg = :dtriangleNo docs available.

marker_pos = :utriangleNo docs available.

n_dodge = automaticNo docs available.

show_direction = falseNo docs available.

show_final = falseNo docs available.

stack = automaticNo docs available.

width = automaticNo docs available.

source


# Makie.waterfall!Function.

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

source


# Makie.with_themeFunction.
julia
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:

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

source


# Makie.xlabel!Method.
julia
xlabel!([scene,] xlabel)

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

source


# Makie.xlims!Function.
julia
xlims!(ax = current_axis())

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

source


# Makie.xlims!Method.
julia
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.

source


# Makie.xlims!Method.
julia
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.

source


# Makie.xticklabelsMethod.
julia
xticklabels(scene)

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

source


# Makie.xtickrangeMethod.
julia
xtickrange(scene)

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

source


# Makie.xtickrotation!Method.
julia
xtickrotation!([scene,] xangle)

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

source


# Makie.xtickrotationMethod.
julia
xtickrotation(scene)

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

source


# Makie.xticks!Method.
julia
xticks!([scene,]; xtickrange=xtickrange(scene), xticklabels=xticklabel(scene))

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

source


# Makie.ylabel!Method.
julia
ylabel!([scene,] ylabel)

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

source


# Makie.ylims!Function.
julia
ylims!(ax = current_axis())

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

source


# Makie.ylims!Method.
julia
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.

source


# Makie.ylims!Method.
julia
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.

source


# Makie.yticklabelsMethod.
julia
yticklabels(scene)

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

source


# Makie.ytickrangeMethod.
julia
ytickrange(scene)

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

source


# Makie.ytickrotation!Method.
julia
ytickrotation!([scene,] yangle)

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

source


# Makie.ytickrotationMethod.
julia
ytickrotation(scene)

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

source


# Makie.yticks!Method.
julia
yticks!([scene,]; ytickrange=ytickrange(scene), yticklabels=yticklabel(scene))

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

source


# Makie.zlabel!Method.
julia
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.

source


# Makie.zlims!Function.
julia
zlims!(ax = current_axis())

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

source


# Makie.zlims!Method.
julia
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.

source


# Makie.zlims!Method.
julia
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.

source


# Makie.zoom!Function.
julia
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.

source


# Makie.zoom!Method.
julia
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.

source


# Makie.zticklabelsMethod.
julia
zticklabels(scene)

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

source


# Makie.ztickrangeMethod.
julia
ztickrange(scene)

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

source


# Makie.ztickrotation!Method.
julia
ztickrotation!([scene,] zangle)

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

source


# Makie.ztickrotationMethod.
julia
ztickrotation(scene)

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

source


# Makie.zticks!Method.
julia
zticks!([scene,]; ztickranges=ztickrange(scene), zticklabels=zticklabel(scene))

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

source


# MakieCore.convert_argumentsMethod.
julia
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.

source


# MakieCore.convert_argumentsMethod.
julia
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).

source


# MakieCore.convert_argumentsMethod.
julia
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).

source


# MakieCore.convert_argumentsMethod.

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

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(PB, LineString)

Takes an input LineString and decomposes it to points.

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(PB, Polygon)

Takes an input Polygon and decomposes it to points.

source


# MakieCore.convert_argumentsMethod.
julia
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).

source


# MakieCore.convert_argumentsMethod.

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

source


# MakieCore.convert_argumentsMethod.
julia
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.

source


# MakieCore.convert_argumentsMethod.
julia
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}.

source


# MakieCore.convert_argumentsMethod.
julia
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.

source


# MakieCore.convert_argumentsMethod.
julia
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.

source


# MakieCore.convert_argumentsMethod.
julia
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).

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(P, x, y, z, i)::(Vector, Vector, Vector, Matrix)

Takes 3 AbstractVector x, y, and z and the AbstractMatrix i, and puts everything in a Tuple.

P is the plot Type (it is optional).

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(P, x, y, z, f)::(Vector, Vector, Vector, Matrix)

Takes AbstractVector x, 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).

source


# MakieCore.convert_argumentsMethod.

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

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(P, x)::(Vector)

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

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(PB, Union{Array{<:LineString}, MultiLineString})

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

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(PB, Union{Array{<:Polygon}, MultiPolygon})

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

source


# MakieCore.convert_argumentsMethod.
julia
convert_arguments(P, x)::(Vector)

Takes an input Rect x and decomposes it to points.

P is the plot Type (it is optional).

source


# MakieCore.used_attributesMethod.
julia
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:

julia
    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

source


# Observables.onMethod.
julia
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!

source


# Makie.@extractMacro.
julia
@extract scene (a, b, c, d)

This becomes

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

source


# Makie.@extractvalueMacro.

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

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

source


# Makie.@get_attributeMacro.
julia
@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:

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

source


# Makie.@liftMacro.

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

Example:

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

before

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

after

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

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

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

source


# MakieCore.ArrowsType.

Arrows is the plot type associated with plotting function arrows. Check the docstring for arrows for further information.

source


# MakieCore.HeatmapType.

Heatmap is the plot type associated with plotting function heatmap. Check the docstring for heatmap for further information.

source


# MakieCore.ImageType.

Image is the plot type associated with plotting function image. Check the docstring for image for further information.

source


# MakieCore.LineSegmentsType.

LineSegments is the plot type associated with plotting function linesegments. Check the docstring for linesegments for further information.

source


# MakieCore.LinesType.

Lines is the plot type associated with plotting function lines. Check the docstring for lines for further information.

source


# MakieCore.MeshType.

Mesh is the plot type associated with plotting function mesh. Check the docstring for mesh for further information.

source


# MakieCore.MeshScatterType.

MeshScatter is the plot type associated with plotting function meshscatter. Check the docstring for meshscatter for further information.

source


# MakieCore.PolyType.

Poly is the plot type associated with plotting function poly. Check the docstring for poly for further information.

source


# MakieCore.ScatterType.

Scatter is the plot type associated with plotting function scatter. Check the docstring for scatter for further information.

source


# MakieCore.SurfaceType.

Surface is the plot type associated with plotting function surface. Check the docstring for surface for further information.

source


# MakieCore.TextType.

Text is the plot type associated with plotting function text. Check the docstring for text for further information.

source


# MakieCore.VolumeType.

Volume is the plot type associated with plotting function volume. Check the docstring for volume for further information.

source


# MakieCore.VoxelsType.

Voxels is the plot type associated with plotting function voxels. Check the docstring for voxels for further information.

source


# MakieCore.WireframeType.

Wireframe is the plot type associated with plotting function wireframe. Check the docstring for wireframe for further information.

source


# MakieCore.arrowsFunction.
julia
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.

Plot type

The plot type alias for the arrows function is Arrows.

Attributes

align = :origin — Sets how arrows are positioned. By default arrows start at the given positions and extend along the given directions. If this attribute is set to :head, :lineend, :tailend, :headstart or :center the given positions will be between the head and tail of each arrow instead.

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

arrowcolor = automatic — Sets the color of the arrow head. Will copy color if set to automatic.

arrowhead = automatic — Defines the marker (2D) or mesh (3D) that is used as the arrow head. The default for is '▲' in 2D and a cone mesh in 3D. For the latter the mesh should start at Point3f(0) and point in positive z-direction.

arrowsize = automatic — Scales the size of the arrow head. This defaults to 0.3 in the 2D case and Vec3f(0.2, 0.2, 0.3) in the 3D case. For the latter the first two components scale the radius (in x/y direction) and the last scales the length of the cone. If the arrowsize is set to 1, the cone will have a diameter and length of 1.

arrowtail = automatic — Defines the mesh used to draw the arrow tail in 3D. It should start at Point3f(0) and extend in negative z-direction. The default is a cylinder. This has no effect on the 2D plot.

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

color = :black — Sets the color of arrowheads and lines. Can be overridden separately using linecolor and arrowcolor.

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

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

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

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

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

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

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

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

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

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

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

lengthscale = 1.0 — Scales the length of the arrow tail.

linecolor = automatic — Sets the color used for the arrow tail which is represented by a line in 2D. Will copy color if set to automatic.

linestyle = nothing — Sets the linestyle used in 2D. Does not apply to 3D plots.

linewidth = automatic — Scales the width/diameter of the arrow tail. Defaults to 1 for 2D and 0.05 for the 3D case.

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

markerspace = :pixelNo docs available.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

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

nan_color = :transparent — The color for NaN values.

normalize = false — By default the lengths of the directions given to arrows are used to scale the length of the arrow tails. If this attribute is set to true the directions are normalized, skipping this scaling.

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

quality = 32 — Defines the number of angle subdivisions used when generating the arrow head and tail meshes. Consider lowering this if you have performance issues. Only applies to 3D plots.

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

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

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

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

transformation = automaticNo docs available.

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

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

source


# MakieCore.arrows!Function.

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

source


# MakieCore.heatmapFunction.
julia
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.

Plot type

The plot type alias for the heatmap function is Heatmap.

Attributes

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

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

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

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

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

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

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

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

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

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

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

interpolate = false — Sets whether colors should be interpolated

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# MakieCore.heatmap!Function.

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

source


# MakieCore.imageFunction.
julia
image(x, y, image)
image(image)

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

Plot type

The plot type alias for the image function is Image.

Attributes

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

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

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

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

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

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

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

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

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

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

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

interpolate = true — Sets whether colors should be interpolated between pixels.

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# MakieCore.image!Function.

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

source


# MakieCore.linesFunction.
julia
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.

Plot type

The plot type alias for the lines function is Lines.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

joinstyle = @inherit joinstyle — Controls the rendering at corners. Options are :miter for sharp corners, :bevel for "cut off" corners, and :round for rounded corners. If the corner angle is below miter_limit, :miter is equivalent to :bevel to avoid long spikes.

linecap = @inherit linecap — Sets the type of line cap used. Options are :butt (flat without extrusion), :square (flat with half a linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

miter_limit = @inherit miter_limit — Sets the minimum inner join angle below which miter joins truncate. See also Makie.miter_distance_to_angle.

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# MakieCore.lines!Function.

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

source


# MakieCore.linesegmentsFunction.
julia
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.

Plot type

The plot type alias for the linesegments function is LineSegments.

Attributes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

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

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

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

nan_color = :transparent — The color for NaN values.

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

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

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

transformation = automaticNo docs available.

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

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

source


# MakieCore.linesegments!Function.

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

source


# MakieCore.meshFunction.
julia
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.

Plot type

The plot type alias for the mesh function is Mesh.

Attributes

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

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

color = @inherit 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.

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

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

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

cycle = [:color => :patchcolor]No docs available.

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

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

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

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

interpolate = true — sets whether colors should be interpolated

lowclip = automatic — The color for any value below the colorrange.

matcap = nothingNo docs available.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.mesh!Function.

mesh! is the mutating variant of plotting function mesh. Check the docstring for mesh for further information.

source


# MakieCore.meshscatterFunction.
julia
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.

Plot type

The plot type alias for the meshscatter function is MeshScatter.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

color = @inherit markercolor — Sets the color of the marker.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

cycle = [:color]No docs available.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

fxaa = true — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

lowclip = automatic — The color for any value below the colorrange.

marker = :Sphere — Sets the scattered mesh.

markersize = 0.1 — Sets the scale of the mesh. This can be given as a Vector to apply to each scattered mesh individually.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

rotation = 0.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.

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.meshscatter!Function.

meshscatter! is the mutating variant of plotting function meshscatter. Check the docstring for meshscatter for further information.

source


# MakieCore.polyFunction.
julia
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).

Plot type

The plot type alias for the poly function is Poly.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit 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.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

cycle = [:color => :patchcolor]No docs available.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

fxaa = true — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

joinstyle = @inherit joinstyleNo docs available.

linecap = @inherit linecapNo docs available.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

lowclip = automatic — The color for any value below the colorrange.

miter_limit = @inherit miter_limitNo docs available.

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

shading = NoShadingNo docs available.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

strokecolor = @inherit patchstrokecolor — Sets the color of the outline around a marker.

strokecolormap = @inherit colormap — Sets the colormap that is sampled for numeric colors.

strokewidth = @inherit patchstrokewidth — Sets the width of the outline.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.poly!Function.

poly! is the mutating variant of plotting function poly. Check the docstring for poly for further information.

source


# MakieCore.scatterFunction.
julia
scatter(positions)
scatter(x, y)
scatter(x, y, z)

Plots a marker for each element in (x, y, z), (x, y), or positions.

Plot type

The plot type alias for the scatter function is Scatter.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit markercolor — Sets the color of the marker. If no color is set, multiple calls to scatter! will cycle through the axis color palette.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

cycle = [:color] — Sets which attributes to cycle when creating multiple plots

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

depthsorting = false — Enables depth-sorting of markers which can improve border artifacts. Currently supported in GLMakie only.

distancefield = nothing — Optional distancefield used for e.g. font and bezier path rendering. Will get set automatically.

fxaa = false — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

glowcolor = (:black, 0.0) — Sets the color of the glow effect around the marker.

glowwidth = 0.0 — Sets the size of a glow effect around the marker.

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

lowclip = automatic — The color for any value below the colorrange.

marker = @inherit marker — Sets the scatter marker.

marker_offset = automatic — The offset of the marker from the given position in markerspace units. Default is centered around the position (markersize * -0.5).

markersize = @inherit markersize — Sets the size of the marker by scaling it relative to its base size which can differ for each marker. A Real scales x and y dimensions by the same amount. A Vec or Tuple with two elements scales x and y separately. An array of either scales each marker separately. Humans perceive the area of a marker as its size which grows quadratically with markersize, so multiplying markersize by 2 results in a marker that is 4 times as large, visually.

markerspace = :pixel — Sets the space in which markersize is given. See Makie.spaces() for possible inputs

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

rotation = Billboard() — Sets the rotation of the marker. A Billboard rotation is always around the depth axis.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

strokecolor = @inherit markerstrokecolor — Sets the color of the outline around a marker.

strokewidth = @inherit markerstrokewidth — Sets the width of the outline around a marker.

transform_marker = 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.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

uv_offset_width = (0.0, 0.0, 0.0, 0.0)No docs available.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.scatter!Function.

scatter! is the mutating variant of plotting function scatter. Check the docstring for scatter for further information.

source


# MakieCore.surfaceFunction.
julia
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, or Matrices which define an irregular grid.

Plot type

The plot type alias for the surface function is Surface.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

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.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

fxaa = true — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

invert_normals = false — Inverts the normals generated for the surface. This can be useful to illuminate the other side of the surface.

lowclip = automatic — The color for any value below the colorrange.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.surface!Function.

surface! is the mutating variant of plotting function surface. Check the docstring for surface for further information.

source


# MakieCore.textFunction.
julia
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.

Plot type

The plot type alias for the text function is Text.

Attributes

align = (:left, :bottom) — Sets the alignment of the string w.r.t. position. Uses :left, :center, :right, :top, :bottom, :baseline or fractions.

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit textcolor — Sets the color of the text. One can set one color per glyph by passing a Vector{<:Colorant}, or one colorant for the whole text. If color is a vector of numbers, the colormap args are used to map the numbers to colors.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

font = @inherit font — Sets the font. Can be a Symbol which will be looked up in the fonts dictionary or a String specifying the (partial) name of a font or the file path of a font file

fonts = @inherit fonts — Used as a dictionary to look up fonts specified by Symbol, for example :regular, :bold or :italic.

fontsize = @inherit fontsize — The fontsize in units depending on markerspace.

fxaa = false — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

glowcolor = (:black, 0.0) — Sets the color of the glow effect around the text.

glowwidth = 0.0 — Sets the size of a glow effect around the text.

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

justification = automatic — Sets the alignment of text w.r.t its bounding box. Can be :left, :center, :right or a fraction. Will default to the horizontal alignment in align.

lineheight = 1.0 — The lineheight multiplier.

lowclip = automatic — The color for any value below the colorrange.

markerspace = :pixel — Sets the space in which fontsize acts. See Makie.spaces() for possible inputs.

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

offset = (0.0, 0.0) — The offset of the text from the given position in markerspace units.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

position = (0.0, 0.0) — Deprecated: Specifies the position of the text. Use the positional argument to text instead.

rotation = 0.0 — Rotates text around the given position

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

strokecolor = (:black, 0.0) — Sets the color of the outline around a marker.

strokewidth = 0 — Sets the width of the outline around a marker.

text = "" — Specifies one piece of text or a vector of texts to show, where the number has to match the number of positions given. Makie supports String which is used for all normal text and LaTeXString which layouts mathematical expressions using MathTeXEngine.jl.

transform_marker = false — Controls whether the model matrix (without translation) applies to the glyph itself, rather than just the positions. (If this is true, scale! and rotate! will affect the text glyphs.)

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

word_wrap_width = -1 — Specifies a linewidth limit for text. If a word overflows this limit, a newline is inserted before it. Negative numbers disable word wrapping.

source


# MakieCore.text!Function.

text! is the mutating variant of plotting function text. Check the docstring for text for further information.

source


# MakieCore.volumeFunction.
julia
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

Plot type

The plot type alias for the volume function is Volume.

Attributes

absorption = 1.0 — Absorption multiplier for algorithm=:absorption. This changes how much light each voxel absorbs.

algorithm = :mip — Sets the volume algorithm that is used.

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

enable_depth = true — Enables depth write for Volume, so that volume correctly occludes other objects.

fxaa = true — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

interpolate = true — Sets whether the volume data should be sampled with interpolation.

isorange = 0.05 — Sets the range of values picked up by the IsoValue algorithm.

isovalue = 0.5 — Sets the target value for the IsoValue algorithm.

lowclip = automatic — The color for any value below the colorrange.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.volume!Function.

volume! is the mutating variant of plotting function volume. Check the docstring for volume for further information.

source


# MakieCore.voxelsFunction.
julia
voxels(x, y, z, chunk::Array{<:Real, 3})
voxels(chunk::Array{<:Real, 3})

Plots a chunk of voxels centered at 0. Optionally the placement and scaling of the chunk can be given as range-like x, y and z. (Only the extrema are considered here. Voxels are always uniformly sized.)

Internally voxels are represented as 8 bit unsigned integer, with 0x00 always being an invisible "air" voxel. Passing a chunk with matching type will directly set those values. Note that color handling is specialized for the internal representation and may behave a bit differently than usual.

Plot type

The plot type alias for the voxels function is Voxels.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

backlight = 0.0 — Sets a weight for secondary light calculation with inverted normals.

color = nothing — Sets colors per voxel id, skipping 0x00. This means that a voxel with id 1 will grab plot.colors[1] and so on up to id 255. This can also be set to a Matrix of colors, i.e. an image for texture mapping.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

depth_shift = 0.0 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

depthsorting = false — Controls the render order of voxels. If set to false voxels close to the viewer are rendered first which should reduce overdraw and yield better performance. If set to true voxels are rendered back to front enabling correct order for transparent voxels.

diffuse = 1.0 — Sets how strongly the red, green and blue channel react to diffuse (scattered) light.

fxaa = true — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

gap = 0.0 — Sets the gap between adjacent voxels in units of the voxel size. This needs to be larger than 0.01 to take effect.

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

interpolate = false — Controls whether the texture map is sampled with interpolation (i.e. smoothly) or not (i.e. pixelated).

is_air = x->begin #= /home/runner/work/Makie.jl/Makie.jl/MakieCore/src/basic_plots.jl:555 =# isnothing(x) || (ismissing(x) || isnan(x)) end — A function that controls which values in the input data are mapped to invisible (air) voxels.

lowclip = automatic — The color for any value below the colorrange.

material = nothing — RPRMakie only attribute to set complex RadeonProRender materials. Warning, how to set an RPR material may change and other backends will ignore this attribute

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

shading = 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.

shininess = 32.0 — Sets how sharp the reflection is.

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

specular = 0.2 — Sets how strongly the object reflects light in the red, green and blue channels.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

uvmap = nothing — Defines a map from voxel ids (and optionally sides) to uv coordinates. These uv coordinates are then used to sample a 2D texture passed through color for texture mapping.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.voxels!Function.

voxels! is the mutating variant of plotting function voxels. Check the docstring for voxels for further information.

source


# MakieCore.wireframeFunction.
julia
wireframe(x, y, z)
wireframe(positions)
wireframe(mesh)

Draws a wireframe, either interpreted as a surface or as a mesh.

Plot type

The plot type alias for the wireframe function is Wireframe.

Attributes

alpha = 1.0 — The alpha value of the colormap or color attribute. Multiple alphas like in plot(alpha=0.2, color=(:red, 0.5), will get multiplied.

color = @inherit linecolor — The color of the line.

colormap = @inherit colormap :viridis — Sets the colormap that is sampled for numeric colors. PlotUtils.cgrad(...), Makie.Reverse(any_colormap) can be used as well, or any symbol from ColorBrewer or PlotUtils. To see all available color gradients, you can call Makie.available_gradients().

colorrange = automatic — The values representing the start and end points of colormap.

colorscale = identity — The color transform function. Can be any function, but only works well together with Colorbar for identity, log, log2, log10, sqrt, logit, Makie.pseudolog10 and Makie.Symlog10.

cycle = [:color] — Sets which attributes to cycle when creating multiple plots.

depth_shift = -1.0e-5 — adjusts the depth value of a plot after all other transformations, i.e. in clip space, where 0 <= depth <= 1. This only applies to GLMakie and WGLMakie and can be used to adjust render order (like a tunable overdraw).

fxaa = false — adjusts whether the plot is rendered with fxaa (anti-aliasing, GLMakie only).

highclip = automatic — The color for any value above the colorrange.

inspectable = true — sets whether this plot should be seen by DataInspector.

inspector_clear = automatic — Sets a callback function (inspector, plot) -> ... for cleaning up custom indicators in DataInspector.

inspector_hover = automatic — Sets a callback function (inspector, plot, index) -> ... which replaces the default show_data methods.

inspector_label = automatic — Sets a callback function (plot, index, position) -> string which replaces the default label generated by DataInspector.

linecap = @inherit linecap — Sets the type of linecap used, i.e. :butt (flat with no extrusion), :square (flat with 1 linewidth extrusion) or :round.

linestyle = nothing — Sets the dash pattern of the line. Options are :solid (equivalent to nothing), :dot, :dash, :dashdot and :dashdotdot. These can also be given in a tuple with a gap style modifier, either :normal, :dense or :loose. For example, (:dot, :loose) or (:dashdot, :dense).

For custom patterns have a look at Makie.Linestyle.

linewidth = @inherit linewidth — Sets the width of the line in pixel units

lowclip = automatic — The color for any value below the colorrange.

model = automatic — Sets a model matrix for the plot. This overrides adjustments made with translate!, rotate! and scale!.

nan_color = :transparent — The color for NaN values.

overdraw = false — Controls if the plot will draw over other plots. This specifically means ignoring depth checks in GL backends

space = :data — sets the transformation space for box encompassing the plot. See Makie.spaces() for possible inputs.

ssao = false — Adjusts whether the plot is rendered with ssao (screen space ambient occlusion). Note that this only makes sense in 3D plots and is only applicable with fxaa = true.

transformation = automaticNo docs available.

transparency = false — Adjusts how the plot deals with transparency. In GLMakie transparency = true results in using Order Independent Transparency.

visible = true — Controls whether the plot will be rendered or not.

source


# MakieCore.wireframe!Function.

wireframe! is the mutating variant of plotting function wireframe. Check the docstring for wireframe for further information.

source


# Makie.AndType.
julia
And(left, right[, rest...])

Creates an And struct with the left and right argument for later evaluation. If more than two arguments are given a tree of And structs is created.

See also: Or, Not, ispressed, &

source


# Makie.NotType.
julia
Not(x)

Creates a Not struct with the given argument for later evaluation.

See also: And, Or, ispressed, !

source


# Makie.OrType.
julia
Or(left, right[, rest...])

Creates an Or struct with the left and right argument for later evaluation. If more than two arguments are given a tree of Or structs is created.

See also: And, Not, ispressed, |

source