## Exported

Makie.AbsoluteType
Absolute


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

source
Makie.Camera3DMethod
Camera3D(scene[; attributes...])


Creates a 3d camera with a lot of controls.

The 3D camera is (or can be) unrestricted in terms of rotations and translations. Both cam3d!(scene) and cam3d_cad!(scene) create this camera type. Unlike the 2D camera, settings and controls are stored in the cam.attributes field rather than in the struct directly, but can still be passed as keyword arguments. The general camera settings include

• fov = 45f0 sets the "neutral" field of view, i.e. the fov corresponding to no zoom. This is irrelevant if the camera uses an orthographic projection.
• near = automatic sets the value of the near clip. By default this will be chosen based on the scenes bounding box. The final value is in cam.near.
• far = automatic sets the value of the far clip. By default this will be chosen based on the scenes bounding box. The final value is in cam.far.
• rotation_center = :lookat sets the default center for camera rotations. Currently allows :lookat or :eyeposition.
• projectiontype = Perspective sets the type of the projection. Can be Orthographic or Perspective.
• fixed_axis = false: If true panning uses the (world/plot) z-axis instead of the camera up direction.
• zoom_shift_lookat = true: If true attempts to keep data under the cursor in view when zooming.
• cad = false: If true rotates the view around lookat when zooming off-center.

The camera view follows from the position of the camera eyeposition, the point which the camera focuses lookat and the up direction of the camera upvector. These can be accessed as cam.eyeposition etc and adjusted via update_cam!(scene, cameracontrols(scene), eyeposition, lookat[, upvector = Vec3f0(0, 0, 1)]). They can also be passed as keyword arguments when the camera is constructed.

The camera can be controlled by keyboard and mouse. The keyboard has the following available attributes

• up_key = Keyboard.left_shift sets the key for translations towards the top of the screen.

• down_key = Keyboard.left_control 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.i sets the key for zooming into the scene (enlarge, via fov).

• zoom_out_key = Keyboard.k sets the key for zooming out of the scene (shrink, via fov).

• stretch_view_key = Keyboard.page_up sets the key for moving eyepostion away from lookat.

• contract_view_key = Keyboard.page_down sets the key for moving eyeposition towards lookat.

• 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.r sets the key for rotations around the screens horizontal axis.

• tilt_down_key = Keyboard.f 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.

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

• update_rate = 1/30 sets the rate at which keyboard based camera updates are evaluated.

and mouse interactions are controlled by

• translation_button = Mouse.right sets the mouse button for drag-translations. (up/down/left/right)

• translation_modifier = nothing sets additional keys that need to be held for mouse translations.

• rotation_button = Mouse.left sets the mouse button for drag-rotations. (pan, tilt)

• rotation_modifier = nothing sets additional keys that need to be held for mouse rotations.

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

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

There are also a few generally applicable controls:

• 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.home sets the key for fully resetting the camera. This equivalent to setting lookat = Vec3f0(0), upvector = Vec3f0(0, 0, 1), eyeposition = Vec3f0(3) and then calling center!(scene).

You can also make adjustments to the camera position, rotation and zoom by calling relevant 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 Vec3f0(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 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.DataInspectorMethod
DataInspector(figure; kwargs...)


Creates a data inspector which will show relevant information in a tooltip when you hover over a plot. If you wish to exclude a plot you may set plot.inspectable[] = false.

Keyword Arguments:

• range = 10: Controls the snapping range for selecting an element of a plot.
• enabled = true: Disables inspection of plots when set to false. Can also be adjusted with enable!(inspector) and disable!(inspector).
• text_padding = Vec4f0(5, 5, 3, 3): Padding for the box drawn around the tooltip text. (left, right, bottom, top)
• text_align = (:left, :bottom): Alignment of text within the tooltip. This does not affect the alignment of the tooltip relative to the cursor.
• textcolor = :black: Tooltip text color.
• textsize = 20: Tooltip text size.
• font = "Dejavu Sans": Tooltip font.
• background_color = :white: Background color of the tooltip.
• outline_color = :grey: Outline color of the tooltip.
• outline_linestyle = nothing: Linestyle of the tooltip outline.
• outline_linewidth = 2: Linewidth of the tooltip outline.
• indicator_color = :red: Color of the selection indicator.
• indicator_linewidth = 2: Linewidth of the selection indicator.
• indicator_linestyle = nothing: Linestyle of the selection indicator
• tooltip_align = (:center, :top): Default position of the tooltip relative to the cursor or current selection. The real align may adjust to keep the tooltip in view.
• tooltip_offset = Vec2f0(20): Offset from the indicator to the tooltip.
• depth = 9e3: Depth value of the tooltip. This should be high so that the tooltip is always in front.
• priority = 100: The priority of creating a tooltip on a mouse movement or scrolling event.
source
Makie.EventsType

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

Functions that act on a PriorityObservable 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 exectued can be controlled via the priority keyword (default 0) in on.

Example:

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

Fields

• window_area::Makie.PriorityObservable{GeometryBasics.HyperRectangle{2, Int64}}

The area of the window in pixels, as a Rect2D.

• window_dpi::Makie.PriorityObservable{Float64}

The DPI resolution of the window, as a Float64.

• window_open::Makie.PriorityObservable{Bool}

The state of the window (open => true, closed => false).

• mousebutton::Makie.PriorityObservable{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::Makie.PriorityObservable{Tuple{Float64, Float64}}

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

• scroll::Makie.PriorityObservable{Tuple{Float64, Float64}}

The direction of scroll

• keyboardbutton::Makie.PriorityObservable{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::Makie.PriorityObservable{Char}

Contains the last typed character.

• dropped_files::Makie.PriorityObservable{Vector{String}}

Contains a list of filepaths to files dragged into the scene.

• hasfocus::Makie.PriorityObservable{Bool}

Whether the Scene window is in focus or not.

• entered_window::Makie.PriorityObservable{Bool}

Whether the mouse is inside the window or not.

source
Makie.PlotSpecType

PlotSpec{P<:AbstractPlot}(args...; kwargs...)

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

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

• px_area

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.

• data_limits

The limits of the data plotted in this scene. Can't be set by user and is only used to store calculated data bounds.

• transformation

The Transformation of the Scene.

• plots

The plots contained in the Scene.

• theme

• attributes

• children

Children of the Scene inherit its transformation.

• current_screens

The Screens which the Scene is displayed to.

• updated

Signal to indicate whether layouting should happen. If updated to true, the Scene will be layouted according to its attributes (raw, center, or scale_plot).

source
Makie.TransformationType

Holds the transformations for Scenes.

Fields

• parent::Base.RefValue{MakieCore.Transformable}

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

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

• rotation::Observable{Quaternionf0}

• model::Observable{StaticArrays.SMatrix{4, 4, Float32, 16}}

• flip::Observable{Tuple{Bool, Bool, Bool}}

• align::Observable{Vec{2, Float32}}

• transform_func::Observable{Any}

source
FileIO.saveMethod
FileIO.save(filename, scene; resolution = 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, .jpeg, and .bmp
• CairoMakie: .svg, .pdf, .png, and .jpeg
• WGLMakie: .png

Supported Keyword Arguments

All Backends

• resolution: (width::Int, height::Int) of the scene in dimensionless units (equivalent to px for GLMakie and WGLMakie).
• update: Update the scene and its children before saving (update_limits! and center!). One might want to set update=false e.g. when saving a zoomed scene.

CairoMakie

• pt_per_unit: The size of one scene unit in pt when exporting to a vector format.
• 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.
source
FileIO.saveMethod
save(path::String, io::VideoStream[; kwargs...])


Flushes the video stream and converts the file to the extension found in path, which can be one of the following:

• .mkv (the default, doesn't need to convert)
• .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 and .gifs are up to 6 times bigger with the same quality!

See the docs of VideoStream for how to create a VideoStream. If you want a simpler interface, consider using record.

Keyword Arguments:

• framrate = 24: The target framerate.
• compression = 0: Controls the video compression with 0 being lossless and 51 being the highest compression. Note that compression = 0 only works with .mp4 if profile = high444.
• 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.
source
Makie.PatternMethod
Pattern(image)


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
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.annotations!Method
annotations(strings::Vector{String}, positions::Vector{Point})


Plots an array of texts at each position in positions.

Attributes

Available attributes and their defaults for Combined{Makie.annotations!, T} where T are:

source
Makie.annotationsMethod
annotations(strings::Vector{String}, positions::Vector{Point})


Plots an array of texts at each position in positions.

Attributes

Available attributes and their defaults for Combined{Makie.annotations, T} where T are:

  align           (:left, :bottom)
ambient         Float32[0.55, 0.55, 0.55]
color           :black
diffuse         Float32[0.4, 0.4, 0.4]
font            "Dejavu Sans"
inspectable     true
justification   MakieCore.Automatic()
lightposition   :eyeposition
lineheight      1.0
linewidth       1
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
offset          (0.0, 0.0)
overdraw        false
position        (0.0, 0.0)
rotation        0.0
shininess       32.0f0
space           :screen
specular        Float32[0.2, 0.2, 0.2]
ssao            false
strokecolor     (:black, 0.0)
strokewidth     0
textsize        20
transparency    false
visible         true
source
Makie.arc!Method
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(Point2f0(0), 1, 0.0, π) arc(Point2f0(1, 2), 0.3. π, -π)

Attributes

Available attributes and their defaults for Combined{Makie.arc!, T} where T are:

source
Makie.arcMethod
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(Point2f0(0), 1, 0.0, π) arc(Point2f0(1, 2), 0.3. π, -π)

Attributes

Available attributes and their defaults for Combined{Makie.arc, T} where T are:

  ambient         Float32[0.55, 0.55, 0.55]
color           :black
colormap        :viridis
colorrange      MakieCore.Automatic()
cycle           [:color]
diffuse         Float32[0.4, 0.4, 0.4]
inspectable     true
lightposition   :eyeposition
linestyle       "nothing"
linewidth       1.5
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
resolution      361
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.arrows!Method
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)


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.

Attributes

Available attributes and their defaults for Combined{Makie.arrows!, T} where T are:

source
Makie.arrowsMethod
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)


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.

Attributes

Available attributes and their defaults for Combined{Makie.arrows, T} where T are:

  align           :origin
ambient         Float32[0.55, 0.55, 0.55]
arrowcolor      MakieCore.Automatic()
arrowsize       MakieCore.Automatic()
arrowtail       MakieCore.Automatic()
color           :black
colormap        :viridis
diffuse         Float32[0.4, 0.4, 0.4]
inspectable     true
lengthscale     1.0f0
lightposition   :eyeposition
linecolor       MakieCore.Automatic()
linestyle       "nothing"
linewidth       MakieCore.Automatic()
markerspace     Pixel
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
normalize       false
overdraw        false
quality         32
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.axis3d!Method
axis3d!(args; attributes...)



Plots a 3-dimensional OldAxis.

Attributes

Available attributes and their defaults for Combined{Makie.axis3d!, T} where T are:

source
Makie.axis3dMethod
axis3d(args; attributes...)



Plots a 3-dimensional OldAxis.

Attributes

OldAxis attributes and their defaults for Combined{Makie.axis3d, T} where T are:

    showaxis: (true, true, true)
showgrid: (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: ("Dejavu Sans", "Dejavu Sans", "Dejavu Sans")
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))
align: ((:left, :center), (:right, :center), (:right, :center))
textsize: (5, 5, 5)
gap: 3
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))
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: ("Dejavu Sans", "Dejavu Sans", "Dejavu Sans")
textcolor: (:black, :black, :black)
align: ((:left, :center), (:right, :center), (:right, :center))
textsize: (6.0, 6.0, 6.0)
gap: 3
inspectable: false
showticks: (true, true, true)
scale: Float32[1.0, 1.0, 1.0]
source
Makie.band!Method
band(x, ylower, yupper; kwargs...)
band(lower, upper; 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.

Attributes

Available attributes and their defaults for Combined{Makie.band!, T} where T are:

source
Makie.bandMethod
band(x, ylower, yupper; kwargs...)
band(lower, upper; 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.

Attributes

Available attributes and their defaults for Combined{Makie.band, T} where T are:

  ambient         Float32[0.55, 0.55, 0.55]
color           :black
colormap        :viridis
colorrange      MakieCore.Automatic()
cycle           [:color => :patchcolor]
diffuse         Float32[0.4, 0.4, 0.4]
inspectable     true
interpolate     false
lightposition   :eyeposition
linewidth       1
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.barplot!Method
barplot(x, y; kwargs...)


Plots a barplot; y defines the height. x and y should be 1 dimensional.

Attributes

Available attributes and their defaults for Combined{Makie.barplot!, T} where T are:

source
Makie.barplotMethod
barplot(x, y; kwargs...)


Plots a barplot; y defines the height. x and y should be 1 dimensional.

Attributes

Available attributes and their defaults for Combined{Makie.barplot, T} where T are:

  bar_labels             "nothing"
color                  RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
color_over_background  MakieCore.Automatic()
color_over_bar         MakieCore.Automatic()
colormap               :viridis
colorrange             MakieCore.Automatic()
cycle                  [:color => :patchcolor]
direction              :y
dodge                  MakieCore.Automatic()
dodge_gap              0.03
fillto                 MakieCore.Automatic()
flip_labels_at         Inf
inspectable            true
label_color            :black
label_font             "Dejavu Sans"
label_formatter        Makie.bar_label_formatter
label_offset           5
label_size             20
marker                 GeometryBasics.HyperRectangle
n_dodge                MakieCore.Automatic()
stack                  MakieCore.Automatic()
strokecolor            :black
strokewidth            0
visible                true
width                  MakieCore.Automatic()
x_gap                  0.2
source
Makie.boxplot!Method
boxplot(x, y; kwargs...)


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

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

Arguments

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

Keywords

• orientation=:vertical: orientation of box (:vertical or :horizontal)
• width=0.8: width of the box
• show_notch=false: draw the notch
• notchwidth=0.5: multiplier of width for narrowest width of notch
• show_median=true: show median as midline
• range: multiple of IQR controlling whisker length
• whiskerwidth: multiplier of width for width of T's on whiskers, or :match to match width
• show_outliers: show outliers as points
source
Makie.boxplotMethod
boxplot(x, y; kwargs...)


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

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

Arguments

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

Keywords

• orientation=:vertical: orientation of box (:vertical or :horizontal)
• width=0.8: width of the box
• show_notch=false: draw the notch
• notchwidth=0.5: multiplier of width for narrowest width of notch
• show_median=true: show median as midline
• range: multiple of IQR controlling whisker length
• whiskerwidth: multiplier of width for width of T's on whiskers, or :match to match width
• show_outliers: show outliers as points
source
Makie.broadcast_foreachMethod
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.contour!Method
contour(x, y, z)


Creates a contour plot of the plane spanning x::Vector, y::Vector, z::Matrix

Attributes

Available attributes and their defaults for Combined{Makie.contour!, T} where T are:

source
Makie.contourMethod
contour(x, y, z)


Creates a contour plot of the plane spanning x::Vector, y::Vector, z::Matrix

Attributes

Available attributes and their defaults for Combined{Makie.contour, T} where T are:

  alpha           1.0
ambient         Float32[0.55, 0.55, 0.55]
color           "nothing"
colormap        :viridis
colorrange      MakieCore.Automatic()
diffuse         Float32[0.4, 0.4, 0.4]
fillrange       false
inspectable     true
levels          5
lightposition   :eyeposition
linewidth       1.0
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.contour3d!Method
contour3d(x, y, z)


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

Attributes

Available attributes and their defaults for Combined{Makie.contour3d!, T} where T are:

source
Makie.contour3dMethod
contour3d(x, y, z)


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

Attributes

Available attributes and their defaults for Combined{Makie.contour3d, T} where T are:

  alpha           1.0
ambient         Float32[0.55, 0.55, 0.55]
color           "nothing"
colormap        :viridis
colorrange      MakieCore.Automatic()
diffuse         Float32[0.4, 0.4, 0.4]
fillrange       false
inspectable     true
levels          5
lightposition   :eyeposition
linewidth       1.0
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.contourf!Method
contourf(xs, ys, zs; kwargs...)


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

The attribute levels can be either

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

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

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

Attributes

Available attributes and their defaults for Combined{Makie.contourf!, T} where T are:

source
Makie.contourfMethod
contourf(xs, ys, zs; kwargs...)


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

The attribute levels can be either

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

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

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

Attributes

Available attributes and their defaults for Combined{Makie.contourf, T} where T are:

  colormap     :viridis
extendhigh   "nothing"
extendlow    "nothing"
inspectable  true
levels       10
mode         :normal
source
Makie.crossbar!Method
crossbar(x, y, ymin, ymax; kwargs...)


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

Arguments

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

Keywords

• orientation=:vertical: orientation of box (:vertical or :horizontal)
• width=0.8: width of the box
• show_notch=false: draw the notch
• notchmin=automatic: lower limit of the notch
• notchmax=automatic: upper limit of the notch
• notchwidth=0.5: multiplier of width for narrowest width of notch
• show_midline=true: show midline
source
Makie.crossbarMethod
crossbar(x, y, ymin, ymax; kwargs...)


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

Arguments

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

Keywords

• orientation=:vertical: orientation of box (:vertical or :horizontal)
• width=0.8: width of the box
• show_notch=false: draw the notch
• notchmin=automatic: lower limit of the notch
• notchmax=automatic: upper limit of the notch
• notchwidth=0.5: multiplier of width for narrowest width of notch
• show_midline=true: show midline
source
Makie.density!Method
density(values; npoints = 200, offset = 0.0, direction = :x)


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

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

Attributes

Available attributes and their defaults for Combined{Makie.density!, T} where T are:

source
Makie.densityMethod
density(values; npoints = 200, offset = 0.0, direction = :x)


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

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

Attributes

Available attributes and their defaults for Combined{Makie.density, T} where T are:

  bandwidth     MakieCore.Automatic()
boundary      MakieCore.Automatic()
color         RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
colormap      :viridis
colorrange    MakieCore.Automatic()
cycle         [:color => :patchcolor]
direction     :x
inspectable   true
linestyle     "nothing"
npoints       200
offset        0.0
strokearound  false
strokecolor   :black
strokewidth   0
source
Makie.errorbars!Method
errorbars(x, y, error_both; kwargs...)
errorbars(x, y, error_low, error_high; kwargs...)
errorbars(x, y, error_low_high; kwargs...)

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

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


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

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

Attributes

Available attributes and their defaults for Combined{Makie.errorbars!, T} where T are:

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

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

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


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

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

Attributes

Available attributes and their defaults for Combined{Makie.errorbars, T} where T are:

  color         :black
colormap      :viridis
direction     :y
inspectable   true
linewidth     1.5
visible       true
whiskerwidth  0
source
Makie.fill_between!Method
fill_between!(x, y1, y2; where = nothing, scene = current_scene(), kw_args...)


fill the section between 2 lines with the condition where

source
Makie.helpMethod
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_attributesMethod
help_attributes([io], Union{PlotType, PlotFunction}; extended = false)


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

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

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

source
Makie.hist!Method
hist(values; bins = 15, normalization = :none)


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

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

Color can either be:

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

Attributes

Available attributes and their defaults for Combined{Makie.hist!, T} where T are:

source
Makie.histMethod
hist(values; bins = 15, normalization = :none)


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

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

Color can either be:

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

Attributes

Available attributes and their defaults for Combined{Makie.hist, T} where T are:

  bar_labels             "nothing"
bins                   15
color                  RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
cycle                  [:color => :patchcolor]
flip_labels_at         Inf
label_color            :black
label_font             "Dejavu Sans"
label_formatter        Makie.bar_label_formatter
label_offset           5
label_size             20
normalization          :none
over_background_color  MakieCore.Automatic()
over_bar_color         MakieCore.Automatic()
source
Makie.hovered_sceneMethod
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.ispressedMethod
ispressed(scene, button)


Returns true if button is pressed in the given scene. The button can be a Keyboard button (e.g. Keyboard.a), a Mouse button (e.g. Mouse.left) or nothing. In the latter case true is always returned.

source
Makie.ispressedMethod
ispressed(scene, buttons)


Returns true if all buttons are pressed in the given scene. buttons can be a Vector or Tuple of Keyboard buttons (e.g. Keyboard.a), Mouse buttons (e.g. Mouse.left) and nothing.

source
Makie.liftMethod
lift(f, o1::Observables.AbstractObservable, rest...)


Create a new Observable by applying f to all observables in o1 and rest.... The initial value is determined by the first function evaluation.

source
Makie.map_onceMethod
map_once(closure, inputs::Node....)::Node


Like Reactive.foreach, in the sense that it will be preserved even if no reference is kept. The difference is, that you can call map once multiple times with the same closure and it will close the old result Node and register a new one instead.

 function test(s1::Node) s3 = maponce(x-> (println("1 ", x); x), s1) s3 = maponce(x-> (println("2 ", x); x), s1)

end test(Node(1), Node(2))

source
Makie.mouseoverMethod
mouseover(scene::SceneLike, plots::AbstractPlot...)


Returns true if the mouse currently hovers any of plots.

source
Makie.mousepositionFunction
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_cad!Method
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.onpickFunction
onpick(func, plot)


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

source
Makie.onpickMethod
onpick(f, scene::SceneLike, 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.pickMethod
pick(scene::Scene, xy::VecLike, range)


Return the plot closest to xy within a given range.

source
Makie.pickMethod
pick(scene::Scene, rect::IRect2D)


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

source
Makie.pickMethod
pick(scene, x, y)


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

source
Makie.pie!Method
pie(fractions; kwargs...)


Creates a pie chart with the given fractions.

Attributes

Available attributes and their defaults for Combined{Makie.pie!, T} where T are:

source
Makie.pieMethod
pie(fractions; kwargs...)


Creates a pie chart with the given fractions.

Attributes

Available attributes and their defaults for Combined{Makie.pie, T} where T are:

  color           :gray
inspectable     true
normalize       true
offset          0
strokecolor     :black
strokewidth     1
vertex_per_deg  1
source
Makie.poly!Method
poly(vertices, indices; kwargs...)
poly(points; kwargs...)
poly(shape; kwargs...)
poly(mesh; kwargs...)


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

poly(coordinates, connectivity; kwargs...)

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

Attributes

Available attributes and their defaults for Combined{Makie.poly!, T} where T are:

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


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

poly(coordinates, connectivity; kwargs...)

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

Attributes

Available attributes and their defaults for Combined{Makie.poly, T} where T are:

  color         RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.6f0)
colormap      :viridis
colorrange    MakieCore.Automatic()
cycle         [:color => :patchcolor]
inspectable   true
linestyle     "nothing"
overdraw      false
strokecolor   :black
strokewidth   0
transparency  false
visible       true
source
Makie.rangebars!Method
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.

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

Attributes

Available attributes and their defaults for Combined{Makie.rangebars!, T} where T are:

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

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

Attributes

Available attributes and their defaults for Combined{Makie.rangebars, T} where T are:

  color         :black
colormap      :viridis
direction     :y
inspectable   true
linewidth     1.5
visible       true
whiskerwidth  0
source
Makie.recordMethod
record(func, figure, path; framerate = 24, compression = 20, kwargs...)
record(func, figure, path, iter; framerate = 24, compression = 20, 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. Allowable extensions are:

• .mkv (the default, doesn't need to convert)
• .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 and .gifs are up to 6 times bigger with the same quality!

The compression argument controls the compression ratio; 51 is the highest compression, and 0 or 1 is the lowest (with 0 being lossless).

Typical usage patterns would look like:

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


or, for more tweakability,

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


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

Extended help

Examples

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


or

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


Keyword Arguments:

• framrate = 24: The target framerate.
• compression = 0: Controls the video compression with 0 being lossless and 51 being the highest compression. Note that compression = 0 only works with .mp4 if profile = high444.
• 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.
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.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.rotate!Method
rotate!(scene::Transformable, axis_rot::Quaternion)
rotate!(scene::Transformable, axis_rot::AbstractFloat)
rotate!(scene::Transformable, axis_rot...)


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

source
Makie.rotate!Method
rotate!(Accum, scene::Transformable, axis_rot...)


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

source
Makie.rotate_cam!Method
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
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.scatterlines!Method
scatterlines(xs, ys, [zs]; kwargs...)


Plots scatter markers and lines between them.

Attributes

Available attributes and their defaults for Combined{Makie.scatterlines!, T} where T are:

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


Plots scatter markers and lines between them.

Attributes

Available attributes and their defaults for Combined{Makie.scatterlines, T} where T are:

  color             :black
colormap          :viridis
colorrange        MakieCore.Automatic()
inspectable       true
linestyle         "nothing"
linewidth         1.5
marker            Circle{T} where T
markercolor       :black
markercolormap    :viridis
markercolorrange  MakieCore.Automatic()
markersize        9
strokecolor       :black
strokewidth       0
source
Makie.select_lineMethod
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
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
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.series!Method
series(curves;
linewidth=2,
color=:lighttest,
solid_color=nothing,
labels=nothing,
# scatter arguments, if any is set != nothing, a scatterplot is added
marker=nothing,
markersize=nothing,
markercolor=automatic,
strokecolor=nothing,
strokewidth=nothing)


Curves can be:

• AbstractVector{<: AbstractVector{<: Point2}}: the native representation of a series as a vector of lines
• AbstractMatrix: each row represents y coordinates of the line, while x goes from 1:size(curves, 1)
• AbstractVector, AbstractMatrix: the same as the above, but the first argument sets the x values for all lines
• AbstractVector{<: Tuple{X<: AbstractVector, Y<: AbstractVector}}: A vector of tuples, where each tuple contains a vector for the x and y coordinates
source
Makie.seriesMethod
series(curves;
linewidth=2,
color=:lighttest,
solid_color=nothing,
labels=nothing,
# scatter arguments, if any is set != nothing, a scatterplot is added
marker=nothing,
markersize=nothing,
markercolor=automatic,
strokecolor=nothing,
strokewidth=nothing)


Curves can be:

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


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

source
Makie.showgradientsMethod
showgradients(
h = 0.0, offset = 0.2, textsize = 0.7,
resolution = (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.spy!Method

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

Visualizes big sparse matrices. Usage:

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


Attributes

Available attributes and their defaults for Combined{Makie.spy!, T} where T are:

source
Makie.spyMethod

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

Visualizes big sparse matrices. Usage:

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


Attributes

Available attributes and their defaults for Combined{Makie.spy, T} where T are:

  colormap     :viridis
colorrange   MakieCore.Automatic()
framecolor   :black
framesize    1
inspectable  true
marker       MakieCore.Automatic()
markersize   MakieCore.Automatic()
source
Makie.stairs!Method
stairs(xs, ys; kwargs...)


Plot a stair function.

The step parameter can take the following values:

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

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Combined{Makie.stairs!, T} where T are:

source
Makie.stairsMethod
stairs(xs, ys; kwargs...)


Plot a stair function.

The step parameter can take the following values:

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

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Combined{Makie.stairs, T} where T are:

  ambient         Float32[0.55, 0.55, 0.55]
color           :black
colormap        :viridis
colorrange      MakieCore.Automatic()
cycle           [:color]
diffuse         Float32[0.4, 0.4, 0.4]
inspectable     true
lightposition   :eyeposition
linestyle       "nothing"
linewidth       1.5
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
step            :pre
transparency    false
visible         true
source
Makie.stem!Method
stem(xs, ys, [zs]; kwargs...)


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

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

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Combined{Makie.stem!, T} where T are:

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


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

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

The conversion trait of stem is PointBased.

Attributes

Available attributes and their defaults for Combined{Makie.stem, T} where T are:

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

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

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

Example:

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


Attributes

Available attributes and their defaults for Combined{Makie.streamplot!, T} where T are:

Implementation

See the function Makie.streamplot_impl for implementation details.

source
Makie.streamplotMethod

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

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

Example:

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


Attributes

Available attributes and their defaults for Combined{Makie.streamplot, T} where T are:

  ambient         Float32[0.55, 0.55, 0.55]
arrow_size      0.03
color           :black
colormap        :viridis
colorrange      MakieCore.Automatic()
cycle           [:color]
density         1.0
diffuse         Float32[0.4, 0.4, 0.4]
gridsize        (32, 32, 32)
inspectable     true
lightposition   :eyeposition
linestyle       "nothing"
linewidth       1.5
maxsteps        500
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
quality         16
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
stepsize        0.01
transparency    false
visible         true

Implementation

See the function Makie.streamplot_impl for implementation details.

source
Makie.timeseries!Method
timeseries(x::Node{{Union{Number, Point2}}})


Plots a sampled signal. Usage:

signal = Node(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


source
Makie.timeseriesMethod
timeseries(x::Node{{Union{Number, Point2}}})


Plots a sampled signal. Usage:

signal = Node(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


source
Makie.to_colorMethod
to_color(color)


Converts a color symbol (e.g. :blue) to a color RGBA.

source
Makie.to_colormapMethod
to_colormap(cm[, N = 20])


Converts a colormap cm symbol (e.g. :Spectral) to a colormap RGB array, where N specifies the number of color points.

source
Makie.translate!Method
translate!(scene::Transformable, xyz::VecTypes)
translate!(scene::Transformable, xyz...)


Apply an absolute translation to the Scene, translating it to x, y, z.

source
Makie.translate!Method
translate!(Accum, scene::Transformable, xyz...)


Translate the scene relative to its current position.

source
Makie.update!Method
update!(p::Scene)


Updates a Scene and all its children. Update will perform the following operations for every scene:

if !scene.raw[]
scene.update_limits[] && update_limits!(scene)
scene.center[] && center!(scene)
end

source
Makie.update_cam!Function
update_cam!(scene::Scene, eyeposition, lookat, up = Vec3f0(0, 0, 1))


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

source
Makie.update_cam!Method
update_cam!(scene::SceneLike, area)


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

source
Makie.update_cam!Method
update_cam!(scene::SceneLike)


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

source
Makie.update_limits!Function
update_limits!(scene::Scene, new_limits::Rect, padding = Vec3f0(0))


This function updates the limits of the given Scene according to the given Rect.

A Rect is a generalization of a rectangle to n dimensions. It contains two vectors. The first vector defines the origin; the second defines the displacement of the vertices from the origin. This second vector can be thought of in two dimensions as a vector of width (x-axis) and height (y-axis), and in three dimensions as a vector of the width (x-axis), breadth (y-axis), and height (z-axis).

Such a Rect can be constructed using the FRect or FRect3D functions that are exported by Makie.jl. See their documentation for more information.

source
Makie.update_limits!Method
update_limits!(scene::Scene, limits::Union{Automatic, Rect} = scene.limits[], padding = scene.padding[])


This function updates the limits of the Scene passed to it based on its data. If an actual limit is set by the theme or its attributes (scene.limits !== automatic), it will not update the limits. Call update_limits!(scene, automatic) for that.

source
Makie.update_theme!Function
update_theme!(with_theme::Theme; kwargs...)


Updates the current theme incrementally, that means 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.

source
Makie.violin!Method
violin(x, y; kwargs...)


Draw a violin plot.

Arguments

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

Keywords

• orientation=:vertical: orientation of the violins (:vertical or :horizontal)
• width=0.8: width of the violin
• show_median=true: show median as midline
• side=:both: specify :left or :right to only plot the violin on one side
• datalimits: specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema)
source
Makie.violinMethod
violin(x, y; kwargs...)


Draw a violin plot.

Arguments

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

Keywords

• orientation=:vertical: orientation of the violins (:vertical or :horizontal)
• width=0.8: width of the violin
• show_median=true: show median as midline
• side=:both: specify :left or :right to only plot the violin on one side
• datalimits: specify values to trim the violin. Can be a Tuple or a Function (e.g. datalimits=extrema)
source
Makie.volumeslices!Method

VolumeSlices

volumeslices(x, y, z, v)

Draws heatmap slices of the volume v

Attributes

Available attributes and their defaults for Combined{Makie.volumeslices!, T} where T are:

source
Makie.volumeslicesMethod

VolumeSlices

volumeslices(x, y, z, v)

Draws heatmap slices of the volume v

Attributes

Available attributes and their defaults for Combined{Makie.volumeslices, T} where T are:

  colorrange  MakieCore.Automatic()
heatmap     Attributes with 0 entries
source
Makie.wireframe!Method
wireframe(x, y, z)
wireframe(positions)
wireframe(mesh)


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

Attributes

Available attributes and their defaults for Combined{Makie.wireframe!, T} where T are:

source
Makie.wireframeMethod
wireframe(x, y, z)
wireframe(positions)
wireframe(mesh)


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

Attributes

Available attributes and their defaults for Combined{Makie.wireframe, T} where T are:

  ambient         Float32[0.55, 0.55, 0.55]
color           :black
colormap        :viridis
colorrange      MakieCore.Automatic()
cycle           [:color]
diffuse         Float32[0.4, 0.4, 0.4]
inspectable     true
lightposition   :eyeposition
linestyle       "nothing"
linewidth       1.5
nan_color       RGBA{Float32}(0.0f0,0.0f0,0.0f0,0.0f0)
overdraw        false
shininess       32.0f0
specular        Float32[0.2, 0.2, 0.2]
ssao            false
transparency    false
visible         true
source
Makie.with_themeFunction
with_theme(f, theme = Theme(); kwargs...)


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

Example:

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

source
Makie.xlabel!Method
xlabel!([scene,] xlabel)


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

source
Makie.xlims!Method
xlims!(limits::Real...)
xlims!(limits::NTuple{2, Real})
xlims!(scene, limits::Real...)
xlims!(scene, limits::NTuple{2, Real})


Set the x-limits for the given Scene (defaults to current Scene).

source
Makie.xtickrotation!Method
xtickrotation!([scene,] xangle)


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

source
Makie.xtickrotationMethod
xtickrotation(scene)


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

source
Makie.xticks!Function
xticks!([scene,]; xtickrange=xtickrange(scene), xticklabels=xticklabel(scene))


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

source
Makie.ylabel!Method
ylabel!([scene,] ylabel)


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

source
Makie.ylims!Method
ylims!(limits::Real...)
ylims!(limits::NTuple{2, Real})
ylims!(scene, limits::Real...)
ylims!(scene, limits::NTuple{2, Real})


Set the y-limits for the given Scene (defaults to current Scene).

source
Makie.ytickrotation!Method
ytickrotation!([scene,] yangle)


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

source
Makie.ytickrotationMethod
ytickrotation(scene)


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

source
Makie.yticks!Function
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
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!Method
zlims!(limits::Real...)
zlims!(limits::NTuple{2, Real})
zlims!(scene, limits::Real...)
zlims!(scene, limits::NTuple{2, Real})


Set the z-limits for the given Scene (defaults to current Scene).

source
Makie.zoom!Method
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.ztickrotation!Method
ztickrotation!([scene,] zangle)


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

source
Makie.ztickrotationMethod
ztickrotation(scene)


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

source
Makie.zticks!Function
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
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
convert_arguments(P, y)::Vector


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

P is the plot Type (it is optional).

source
MakieCore.convert_argumentsMethod
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
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.convert_argumentsMethod
convert_arguments(PB, Union{Array{<:LineString}, MultiLineString})


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

source
MakieCore.convert_argumentsMethod
convert_arguments(PB, Union{Array{<:Polygon}, MultiPolygon})


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

source
MakieCore.convert_argumentsMethod
convert_arguments(P, Matrix)::Tuple{ClosedInterval, ClosedInterval, Matrix}


Takes an AbstractMatrix, converts the dimesions n and m into ClosedInterval, and stores the ClosedInterval to n and m, plus the original matrix in a Tuple.

P is the plot Type (it is optional).

source
MakieCore.convert_argumentsMethod
convert_arguments(SL::SurfaceLike, x::VecOrMat, y::VecOrMat, z::Matrix)


If SL 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
convert_arguments(P, x, y, z)::Tuple{ClosedInterval, ClosedInterval, Matrix}


Takes 2 ClosedIntervals's x, y, and an AbstractMatrix z, and converts the closed range to linspaces with size(z, 1/2) P is the plot Type (it is optional).

source
MakieCore.convert_argumentsMethod
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
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
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
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
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
convert_arguments(P, Matrix)::Tuple{ClosedInterval, ClosedInterval, ClosedInterval, Matrix}


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

P is the plot Type (it is optional).

source
MakieCore.convert_argumentsMethod
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_attributeFunction

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
MakieCore.convert_attributeMethod
AbstractVector{<:AbstractFloat} for denoting sequences of fill/nofill. e.g.


[0.5, 0.8, 1.2] will result in 0.5 filled, 0.3 unfilled, 0.4 filled. 1.0 unit is one linewidth!

source
MakieCore.convert_attributeMethod
to_volume_algorithm(b, x)


Enum values: IsoValue Absorption MaximumIntensityProjection AbsorptionRGBA AdditiveRGBA IndexedAbsorptionRGBA

source
MakieCore.used_attributesMethod
used_attributes(args...) = ()


function used to indicate what keyword args one wants to get passed in convert_arguments. Usage:

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

source
Observables.onMethod
on(f, c::Camera, nodes::Node...)


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

source
Makie.@extractvalueMacro

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

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

source
Makie.@get_attributeMacro
@get_attribute scene (a, b, c, d)


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

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

source
Makie.@liftMacro

Replaces an expression with lift(argtuple -> expression, args...), where args are all expressions inside the main one that begin with $. Example: x = Node(rand(100)) y = Node(rand(100)) before z = lift((x, y) -> x .+ y, x, y) after z = @lift(x .+ y) You can also use parentheses around an expression if that expression evaluates to a node. nt = (x = Node(1), y = Node(2)) @lift($(nt.x) + \$(nt.y))

source

## Unexported

Makie.AbstractPatternType
AbstractPattern{T} <: AbstractArray{T, 2}


AbstractPatterns are image-like array types which can be used to color plottable objects. There are currently two subtypes: LinePattern and ImagePattern. Any abstract pattern must implement the to_image(pat) function, which must return a Matrix{<: AbstractRGB}.

source
Makie.ColorSamplerType

A colorsampler maps numnber values from a certain range to values of a colormap

x = ColorSampler(colormap, (0.0, 1.0))
x[0.5] # returns color at half point of colormap
source
Makie.DeviceIndependentPixelType

https://en.wikipedia.org/wiki/Device-independent_pixel A device-independent pixel (also: density-independent pixel, dip, dp) is a physical unit of measurement based on a coordinate system held by a computer and represents an abstraction of a pixel for use by an application that an underlying system then converts to physical pixels.

source
Makie.FastPixelType
FastPixel()


Use

scatter(..., marker=FastPixel())


For significant faster plotting times for large amount of points. Note, that this will draw markers always as 1 pixel.

source
Makie.FolderStepperType
Stepper(scene, path; format = :jpg)


Creates a Stepper for generating progressive plot examples.

Each "step" is saved as a separate file in the folder pointed to by path, and the format is customizable by format, which can be any output type your backend supports.

Notice that the relevant Makie.step! is not exported and should be accessed by module name.

source
Makie.LinePatternMethod
LinePattern([; kwargs...])


Creates a LinePattern for the given keyword arguments:

• direction: The direction of the line.
• width: The width of the line
• tilesize: The size of the image on which the line is drawn. This should be

compatible with the direction.

• shift: Sets the starting point for the line.
• linecolor: The color with which the line is replaced.
• background_color:: The background color.

Multiple directions, widths and shifts can also be given to create more complex patterns, e.g. a cross-hatching pattern.

source
Makie.MillimeterType

Millimeter on screen. This unit respects the dimension and pixel density of the screen to represent millimeters on the screen. This is the must use unit for layouting, that needs to look the same on all kind of screens. Similar as with the Pixel unit, a camera can change the actually displayed dimensions of any object using the millimeter unit.

source
Makie.PriorityObservableMethod
PriorityObservable(value)


Creates a new PriorityObservable holding the given value.

A po = PriorityObservable differs from a normal Observable (or Node) in two ways:

1. When registering a function to po you can also give it a priority.

Functions with higher priority will be evaluated first.

1. Each registered function is assumed to return a Bool. If true is returned

the observable will stop calling the remaining observer functions.

In the following example we have 3 listeners to a PriorityObservable. When triggering the PriorityObservable you will first see "First" as it is the callback with the highest priority. After that "Second" will be printed and stop further execution. "Third" will therefore not be printed.

po = PriorityObservable(1)
on(x -> begin printstyled("First
", color=:green); false end, po, priority = 1)
on(x -> begin printstyled("Second
", color=:orange); true end, po, priority = 0)
on(x -> begin printstyled("Third
", color=:red); false end, po, priority = -1)
po[] = 2

Note that PriorityObservable does not implement map. If you wish to know whether any observer function returned true, you can check the output of setindex!(po, val).

source
Makie._group_polysMethod
_group_polys(points, ids)


Given a vector of polygon vertices, and one vector of group indices, which are assumed to be returned from the isoband algorithm, return a vector of groups, where each group has one outer polygon and zero or more inner polygons which are holes in the outer polygon. It is possible that one group has multiple outer polygons with multiple holes each.

source
Makie.colorbufferFunction
colorbuffer(scene, format::ImageStorageFormat = JuliaNative)
colorbuffer(screen, format::ImageStorageFormat = JuliaNative)


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.

• 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
source
Makie.find_font_for_charMethod
find_font_for_char(c::Char, font::NativeFont)


Finds the best font for a character from a list of fallback fonts, that get chosen if font can't represent char c

source
Makie.from_dictMethod
from_dict(::Type{T}, dict)


Creates the type T from the fields in dict. Automatically converts to the correct node types.

source
Makie.frustumMethod
Create view frustum

Parameters
----------
left : float
Left coordinate of the field of view.
right : float
Left coordinate of the field of view.
bottom : float
Bottom coordinate of the field of view.
top : float
Top coordinate of the field of view.
znear : float
Near coordinate of the field of view.
zfar : float
Far coordinate of the field of view.

Returns
-------
M : array
View frustum matrix (4x4).

source
Makie.getscreenMethod
getscreen(scene::Scene)


Gets the current screen a scene is associated with. Returns nothing if not yet displayed on a screen.

source
Makie.glyph_collectionMethod
glyph_collection(str::AbstractString, font_per_char, fontscale_px, halign, valign, lineheight_factor, justification, rotation, color)


Calculate the positions for each glyph in a string given a certain font, font size, alignment, etc. This layout in text coordinates, relative to the anchor point [0,0] can then be translated and rotated to wherever it is needed in the plot.

source
Makie.interpolated_getindexMethod
interpolated_getindex(cmap::AbstractArray, value::AbstractFloat, norm = (0.0, 1.0))


Like getindex, but accepts values between 0..1 and interpolates those to the full range. You can use norm, to change the range of 0..1 to whatever you want.

source
Makie.interpolated_getindexMethod
interpolated_getindex(cmap::AbstractArray, value::AbstractFloat)


Like getindex, but accepts values between 0..1 for value and interpolates those to the full range of cmap.

source
Makie.layout_textMethod
layout_text(
string::AbstractString, textsize::Union{AbstractVector, Number},
font, align, rotation, model, justification, lineheight
)


Compute a GlyphCollection for a string given textsize, font, align, rotation, model, justification, and lineheight.

source
Makie.lookatMethod

view = lookat(eyeposition, lookat, up) creates a view matrix with the eye located at eyeposition and looking at position lookat, with the top of the window corresponding to the direction up. Only the component of up that is perpendicular to the vector pointing from eyeposition to lookat will be used. All inputs must be supplied as 3-vectors.

source
Makie.peaksFunction
peaks([n=49])


Return a nonlinear function on a grid. Useful for test cases.

source
Makie.perspectiveprojectionMethod

proj = perspectiveprojection([T], fovy, aspect, znear, zfar) defines a projection matrix with a given angular field-of-view fovy along the y-axis (measured in degrees), the specified aspect ratio, and near and far clipping planes znear, zfar. Optionally specify the element type T of the matrix.

source
Makie.perspectiveprojectionMethod

proj = perspectiveprojection([T], rect, fov, near, far) defines the projection ratio in terms of the rectangular view size rect rather than the aspect ratio.

source
Makie.pick_sortedMethod
pick_sorted(scene::Scene, xy::VecLike, range)


Return all (plot, index) pairs in a (xy .- range, xy .+ range) region sorted by distance to xy.

source
Makie.print_recFunction
print_rec(io::IO, dict, indent::Int = 1[; extended = false])


Traverses a dictionary dict and recursively print out its keys and values in a nicely-indented format.

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

source
Makie.raw!Method
update!(p::Scene, b::Bool)


Sets raw[]=b on a Scene and all its children 

source
Makie.resampleMethod
resample(A::AbstractVector, len::Integer)


Resample a vector with linear interpolation to have length len

source
Makie.resampled_colorsMethod
resampled_colors(attributes::Attributes, levels::Integer)


Resample the color attribute from attributes. Resamples :colormap if present, or repeats :color.

source
Makie.rotatedrectMethod

Calculate an approximation of a tight rectangle around a 2D rectangle rotated by angle radians. This is not perfect but works well enough. Check an A vs X to see the difference.

source
Makie.sdistancefieldMethod
sdistancefield(img, downsample, pad)


Calculates a distance fields, that is downsampled downsample time, with a padding applied of pad. The padding is in units after downscaling!

source
Makie.setlims!Function
setlims!(scene::Scene, min_max::NTuple{2, Real}, dim=1)


Sets the limits of the scene for dim=1.

source
Makie.showlibraryMethod
showlibrary(lib::Symbol)::Scene


Shows all colour gradients in the given library. Returns a Scene with these colour gradients arranged as horizontal colourbars.

source
Makie.step!Method
step!(s::Stepper)


steps through a Makie.Stepper and outputs a file with filename filename-step.jpg. This is useful for generating progressive plot examples.

source
Makie.streamplot_implMethod

streamplot_impl(CallType, f, limits::Rect{N, T}, resolutionND, stepsize)

Code adapted from an example implementation by Moritz Schauer (@mschauer) from https://github.com/JuliaPlots/Makie.jl/issues/355#issuecomment-504449775

Background: The algorithm puts an arrow somewhere and extends the streamline in both directions from there. Then, it chooses a new position (from the remaining ones), repeating the the exercise until the streamline gets blocked, from which on a new starting point, the process repeats.

So, ideally, the new starting points for streamlines are not too close to current streamlines.

Quasirandom sequences

source
Makie.ticks!Function
ticks!([scene,]; tickranges=tickranges(scene), ticklabels=ticklabels(scene))


Set the tick labels and ranges along all axes. The respective labels and ranges along each axis must be of the same length.

source
Makie.to_spritemarkerMethod

Vector of anything that is accepted as a single marker will give each point it's own marker. Note that it needs to be a uniform vector with the same element type!

source
Makie.to_trianglesMethod
to_triangles(indices)


Convert a representation of triangle point indices indices to its canonical representation as a Vector{Makie.GLTriangleFace}. indices can be any of the following:

• An AbstractVector{Int}, containing groups of 3 1-based indices,
• An AbstractVector{UIn32}, containing groups of 3 0-based indices,
• An AbstractVector of TriangleFace objects,
• An AbstractMatrix of Integers, where each row is a triangle.
source
Makie.to_verticesMethod
to_vertices(v)


Converts a representation of vertices v to its canonical representation as a Vector{Point3f0}. v can be:

• An AbstractVector of 3-element Tuples or StaticVectors,

• An AbstractVector of Tuples or StaticVectors, in which case exta dimensions will be either truncated or padded with zeros as required,

• An AbstractMatrix"

• if v has 2 or 3 rows, it will treat each column as a vertex,
• otherwise if v has 2 or 3 columns, it will treat each row as a vertex.
source
MakieCore.plottypeMethod
plottype(P1::Type{<: Combined{T1}}, P2::Type{<: Combined{T2}})


Chooses the more concrete plot type `julia function convert_arguments(P::PlotFunc, args...) ptype = plottype(P, Lines) ... end

source